]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add Create to wxDocParentFrame
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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_wxLayoutDirection swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRegion swig_types[110]
2577 #define SWIGTYPE_p_wxScrollEvent swig_types[111]
2578 #define SWIGTYPE_p_wxScrollWinEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSetCursorEvent swig_types[113]
2580 #define SWIGTYPE_p_wxShowEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSize swig_types[115]
2582 #define SWIGTYPE_p_wxSizeEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSizer swig_types[117]
2584 #define SWIGTYPE_p_wxSizerItem swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBox swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[121]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[122]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[123]
2590 #define SWIGTYPE_p_wxToolTip swig_types[124]
2591 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[125]
2592 #define SWIGTYPE_p_wxValidator swig_types[126]
2593 #define SWIGTYPE_p_wxVisualAttributes swig_types[127]
2594 #define SWIGTYPE_p_wxWindow swig_types[128]
2595 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[129]
2596 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[130]
2597 #define SWIGTYPE_p_wxXPMHandler swig_types[131]
2598 #define SWIGTYPE_p_wxZipFSHandler swig_types[132]
2599 static swig_type_info *swig_types[134];
2600 static swig_module_info swig_module = {swig_types, 133, 0, 0, 0, 0};
2601 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2602 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2603
2604 /* -------- TYPES TABLE (END) -------- */
2605
2606 #if (PY_VERSION_HEX <= 0x02000000)
2607 # if !defined(SWIG_PYTHON_CLASSIC)
2608 # error "This python version requires to use swig with the '-classic' option"
2609 # endif
2610 #endif
2611 #if (PY_VERSION_HEX <= 0x02020000)
2612 # error "This python version requires to use swig with the '-nomodern' option"
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodernargs' option"
2616 #endif
2617 #ifndef METH_O
2618 # error "This python version requires to use swig with the '-nofastunpack' option"
2619 #endif
2620
2621 /*-----------------------------------------------
2622 @(target):= _core_.so
2623 ------------------------------------------------*/
2624 #define SWIG_init init_core_
2625
2626 #define SWIG_name "_core_"
2627
2628 #define SWIGVERSION 0x010329
2629
2630
2631 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2632 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2633
2634
2635 #include <stdexcept>
2636
2637
2638 namespace swig {
2639 class PyObject_ptr {
2640 protected:
2641 PyObject *_obj;
2642
2643 public:
2644 PyObject_ptr() :_obj(0)
2645 {
2646 }
2647
2648 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2649 {
2650 Py_XINCREF(_obj);
2651 }
2652
2653 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2654 {
2655 if (initial_ref) Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr & operator=(const PyObject_ptr& item)
2659 {
2660 Py_XINCREF(item._obj);
2661 Py_XDECREF(_obj);
2662 _obj = item._obj;
2663 return *this;
2664 }
2665
2666 ~PyObject_ptr()
2667 {
2668 Py_XDECREF(_obj);
2669 }
2670
2671 operator PyObject *() const
2672 {
2673 return _obj;
2674 }
2675
2676 PyObject *operator->() const
2677 {
2678 return _obj;
2679 }
2680 };
2681 }
2682
2683
2684 namespace swig {
2685 struct PyObject_var : PyObject_ptr {
2686 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2687
2688 PyObject_var & operator = (PyObject* obj)
2689 {
2690 Py_XDECREF(_obj);
2691 _obj = obj;
2692 return *this;
2693 }
2694 };
2695 }
2696
2697
2698 #include "wx/wxPython/wxPython_int.h"
2699 #include "wx/wxPython/pyclasses.h"
2700 #include "wx/wxPython/twoitem.h"
2701
2702
2703 #ifndef wxPyUSE_EXPORT
2704 // Helper functions for dealing with SWIG objects and such. These are
2705 // located here so they know about the SWIG types and functions declared
2706 // in the wrapper code.
2707
2708 #include <wx/hashmap.h>
2709 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2710
2711
2712 // Maintains a hashmap of className to swig_type_info pointers. Given the
2713 // name of a class either looks up the type info in the cache, or scans the
2714 // SWIG tables for it.
2715 extern PyObject* wxPyPtrTypeMap;
2716 static
2717 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2718
2719 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2720
2721 if (typeInfoCache == NULL)
2722 typeInfoCache = new wxPyTypeInfoHashMap;
2723
2724 wxString name(className);
2725 swig_type_info* swigType = (*typeInfoCache)[name];
2726
2727 if (! swigType) {
2728 // it wasn't in the cache, so look it up from SWIG
2729 name.Append(wxT(" *"));
2730 swigType = SWIG_TypeQuery(name.mb_str());
2731
2732 // if it still wasn't found, try looking for a mapped name
2733 if (!swigType) {
2734 PyObject* item;
2735 name = className;
2736
2737 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2738 (char*)(const char*)name.mbc_str())) != NULL) {
2739 name = wxString(PyString_AsString(item), *wxConvCurrent);
2740 name.Append(wxT(" *"));
2741 swigType = SWIG_TypeQuery(name.mb_str());
2742 }
2743 }
2744 if (swigType) {
2745 // and add it to the map if found
2746 (*typeInfoCache)[className] = swigType;
2747 }
2748 }
2749 return swigType;
2750 }
2751
2752
2753 // Check if a class name is a type known to SWIG
2754 bool wxPyCheckSwigType(const wxChar* className) {
2755
2756 swig_type_info* swigType = wxPyFindSwigType(className);
2757 return swigType != NULL;
2758 }
2759
2760
2761 // Given a pointer to a C++ object and a class name, construct a Python proxy
2762 // object for it.
2763 PyObject* wxPyConstructObject(void* ptr,
2764 const wxChar* className,
2765 int setThisOwn) {
2766
2767 swig_type_info* swigType = wxPyFindSwigType(className);
2768 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2769
2770 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2771 }
2772
2773
2774 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2775 // Ensures that the proxy object is of the specified (or derived) type. If
2776 // not able to perform the conversion then a Python exception is set and the
2777 // error should be handled properly in the caller. Returns True on success.
2778 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2779 const wxChar* className) {
2780
2781 swig_type_info* swigType = wxPyFindSwigType(className);
2782 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2783
2784 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2785 }
2786
2787
2788
2789 // Make a SWIGified pointer object suitable for a .this attribute
2790 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2791
2792 PyObject* robj = NULL;
2793
2794 swig_type_info* swigType = wxPyFindSwigType(className);
2795 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2796
2797 robj = PySwigObject_New(ptr, swigType, 0);
2798 return robj;
2799 }
2800
2801
2802 // Python's PyInstance_Check does not return True for instances of new-style
2803 // classes. This should get close enough for both new and old classes but I
2804 // should re-evaluate the need for doing instance checks...
2805 bool wxPyInstance_Check(PyObject* obj) {
2806 return PyObject_HasAttrString(obj, "__class__") != 0;
2807 }
2808
2809
2810 // This one checks if the object is an instance of a SWIG proxy class (it has
2811 // a .this attribute, and the .this attribute is a PySwigObject.)
2812 bool wxPySwigInstance_Check(PyObject* obj) {
2813 static PyObject* this_str = NULL;
2814 if (this_str == NULL)
2815 this_str = PyString_FromString("this");
2816
2817 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2818 if (this_attr) {
2819 bool retval = (PySwigObject_Check(this_attr) != 0);
2820 Py_DECREF(this_attr);
2821 return retval;
2822 }
2823
2824 PyErr_Clear();
2825 return false;
2826 }
2827
2828
2829 // Export a C API in a struct. Other modules will be able to load this from
2830 // the wx._core_ module and will then have safe access to these functions,
2831 // even if they are located in another shared library.
2832 static wxPyCoreAPI API = {
2833
2834 wxPyCheckSwigType,
2835 wxPyConstructObject,
2836 wxPyConvertSwigPtr,
2837 wxPyMakeSwigPtr,
2838
2839 wxPyBeginAllowThreads,
2840 wxPyEndAllowThreads,
2841 wxPyBeginBlockThreads,
2842 wxPyEndBlockThreads,
2843
2844 wxPy_ConvertList,
2845
2846 wxString_in_helper,
2847 Py2wxString,
2848 wx2PyString,
2849
2850 byte_LIST_helper,
2851 int_LIST_helper,
2852 long_LIST_helper,
2853 string_LIST_helper,
2854 wxPoint_LIST_helper,
2855 wxBitmap_LIST_helper,
2856 wxString_LIST_helper,
2857 wxAcceleratorEntry_LIST_helper,
2858
2859 wxSize_helper,
2860 wxPoint_helper,
2861 wxRealPoint_helper,
2862 wxRect_helper,
2863 wxColour_helper,
2864 wxPoint2D_helper,
2865
2866 wxPySimple_typecheck,
2867 wxColour_typecheck,
2868
2869 wxPyCBH_setCallbackInfo,
2870 wxPyCBH_findCallback,
2871 wxPyCBH_callCallback,
2872 wxPyCBH_callCallbackObj,
2873 wxPyCBH_delete,
2874
2875 wxPyMake_wxObject,
2876 wxPyMake_wxSizer,
2877 wxPyPtrTypeMap_Add,
2878 wxPy2int_seq_helper,
2879 wxPy4int_seq_helper,
2880 wxArrayString2PyList_helper,
2881 wxArrayInt2PyList_helper,
2882
2883 wxPyClientData_dtor,
2884 wxPyUserData_dtor,
2885 wxPyOORClientData_dtor,
2886
2887 wxPyCBInputStream_create,
2888 wxPyCBInputStream_copy,
2889
2890 wxPyInstance_Check,
2891 wxPySwigInstance_Check,
2892
2893 wxPyCheckForApp
2894
2895 };
2896
2897 #endif
2898
2899
2900 #if !WXWIN_COMPATIBILITY_2_4
2901 #define wxHIDE_READONLY 0
2902 #endif
2903
2904
2905 #define SWIG_From_long PyInt_FromLong
2906
2907
2908 SWIGINTERNINLINE PyObject *
2909 SWIG_From_int (int value)
2910 {
2911 return SWIG_From_long (value);
2912 }
2913
2914 static const wxString wxPyEmptyString(wxEmptyString);
2915 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2916 return self->GetClassInfo()->GetClassName();
2917 }
2918 SWIGINTERN void wxObject_Destroy(wxObject *self){
2919 delete self;
2920 }
2921
2922 #ifndef __WXMAC__
2923 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2924 #endif
2925
2926
2927 #include <limits.h>
2928 #ifndef LLONG_MIN
2929 # define LLONG_MIN LONG_LONG_MIN
2930 #endif
2931 #ifndef LLONG_MAX
2932 # define LLONG_MAX LONG_LONG_MAX
2933 #endif
2934 #ifndef ULLONG_MAX
2935 # define ULLONG_MAX ULONG_LONG_MAX
2936 #endif
2937
2938
2939 SWIGINTERN int
2940 SWIG_AsVal_long (PyObject* obj, long* val)
2941 {
2942 if (PyNumber_Check(obj)) {
2943 if (val) *val = PyInt_AsLong(obj);
2944 return SWIG_OK;
2945 }
2946 return SWIG_TypeError;
2947 }
2948
2949
2950 SWIGINTERN int
2951 SWIG_AsVal_int (PyObject * obj, int *val)
2952 {
2953 long v;
2954 int res = SWIG_AsVal_long (obj, &v);
2955 if (SWIG_IsOK(res)) {
2956 if ((v < INT_MIN || v > INT_MAX)) {
2957 return SWIG_OverflowError;
2958 } else {
2959 if (val) *val = static_cast< int >(v);
2960 }
2961 }
2962 return res;
2963 }
2964
2965 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return false;
2968 if ( ! wxSize_helper(other, &obj) ) {
2969 PyErr_Clear();
2970 return false;
2971 }
2972 return self->operator==(*obj);
2973 }
2974 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2975 wxSize temp, *obj = &temp;
2976 if ( other == Py_None ) return true;
2977 if ( ! wxSize_helper(other, &obj)) {
2978 PyErr_Clear();
2979 return true;
2980 }
2981 return self->operator!=(*obj);
2982 }
2983
2984 #include <float.h>
2985
2986
2987 SWIGINTERN int
2988 SWIG_AsVal_double (PyObject *obj, double* val)
2989 {
2990 if (PyNumber_Check(obj)) {
2991 if (val) *val = PyFloat_AsDouble(obj);
2992 return SWIG_OK;
2993 }
2994 return SWIG_TypeError;
2995 }
2996
2997
2998 SWIGINTERN int
2999 SWIG_AsVal_float (PyObject * obj, float *val)
3000 {
3001 double v;
3002 int res = SWIG_AsVal_double (obj, &v);
3003 if (SWIG_IsOK(res)) {
3004 if ((v < -FLT_MAX || v > FLT_MAX)) {
3005 return SWIG_OverflowError;
3006 } else {
3007 if (val) *val = static_cast< float >(v);
3008 }
3009 }
3010 return res;
3011 }
3012
3013 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 PyObject* tup = PyTuple_New(2);
3016 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3017 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3018 wxPyEndBlockThreads(blocked);
3019 return tup;
3020 }
3021
3022 #define SWIG_From_double PyFloat_FromDouble
3023
3024 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3025 wxRealPoint temp, *obj = &temp;
3026 if ( other == Py_None ) return false;
3027 if ( ! wxRealPoint_helper(other, &obj) ) {
3028 PyErr_Clear();
3029 return false;
3030 }
3031 return self->operator==(*obj);
3032 }
3033 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3034 wxRealPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return true;
3036 if ( ! wxRealPoint_helper(other, &obj)) {
3037 PyErr_Clear();
3038 return true;
3039 }
3040 return self->operator!=(*obj);
3041 }
3042 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3043 self->x = x;
3044 self->y = y;
3045 }
3046 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3048 PyObject* tup = PyTuple_New(2);
3049 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3050 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3051 wxPyEndBlockThreads(blocked);
3052 return tup;
3053 }
3054 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3055 wxPoint temp, *obj = &temp;
3056 if ( other == Py_None ) return false;
3057 if ( ! wxPoint_helper(other, &obj) ) {
3058 PyErr_Clear();
3059 return false;
3060 }
3061 return self->operator==(*obj);
3062 }
3063 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3064 wxPoint temp, *obj = &temp;
3065 if ( other == Py_None ) return true;
3066 if ( ! wxPoint_helper(other, &obj)) {
3067 PyErr_Clear();
3068 return true;
3069 }
3070 return self->operator!=(*obj);
3071 }
3072 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3073 self->x = x;
3074 self->y = y;
3075 }
3076 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 PyObject* tup = PyTuple_New(2);
3079 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3080 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3081 wxPyEndBlockThreads(blocked);
3082 return tup;
3083 }
3084 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3085 wxRect temp, *obj = &temp;
3086 if ( other == Py_None ) return false;
3087 if ( ! wxRect_helper(other, &obj) ) {
3088 PyErr_Clear();
3089 return false;
3090 }
3091 return self->operator==(*obj);
3092 }
3093 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3094 wxRect temp, *obj = &temp;
3095 if ( other == Py_None ) return true;
3096 if ( ! wxRect_helper(other, &obj)) {
3097 PyErr_Clear();
3098 return true;
3099 }
3100 return self->operator!=(*obj);
3101 }
3102 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3103 self->x = x;
3104 self->y = y;
3105 self->width = width;
3106 self->height = height;
3107 }
3108 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 PyObject* tup = PyTuple_New(4);
3111 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3112 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3113 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3114 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3115 wxPyEndBlockThreads(blocked);
3116 return tup;
3117 }
3118
3119 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3120 wxRegion reg1(*r1);
3121 wxRegion reg2(*r2);
3122 wxRect dest(0,0,0,0);
3123 PyObject* obj;
3124
3125 reg1.Intersect(reg2);
3126 dest = reg1.GetBox();
3127
3128 if (dest != wxRect(0,0,0,0)) {
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3130 wxRect* newRect = new wxRect(dest);
3131 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3132 wxPyEndBlockThreads(blocked);
3133 return obj;
3134 }
3135 Py_INCREF(Py_None);
3136 return Py_None;
3137 }
3138
3139 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3140 wxPoint2D temp, *obj = &temp;
3141 if ( other == Py_None ) return false;
3142 if ( ! wxPoint2D_helper(other, &obj) ) {
3143 PyErr_Clear();
3144 return false;
3145 }
3146 return self->operator==(*obj);
3147 }
3148 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3149 wxPoint2D temp, *obj = &temp;
3150 if ( other == Py_None ) return true;
3151 if ( ! wxPoint2D_helper(other, &obj)) {
3152 PyErr_Clear();
3153 return true;
3154 }
3155 return self->operator!=(*obj);
3156 }
3157 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3158 self->m_x = x;
3159 self->m_y = y;
3160 }
3161 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3163 PyObject* tup = PyTuple_New(2);
3164 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3165 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3166 wxPyEndBlockThreads(blocked);
3167 return tup;
3168 }
3169
3170 #include "wx/wxPython/pyistream.h"
3171
3172 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3173 wxInputStream* wxis = wxPyCBInputStream::create(p);
3174 if (wxis)
3175 return new wxPyInputStream(wxis);
3176 else
3177 return NULL;
3178 }
3179
3180 SWIGINTERN swig_type_info*
3181 SWIG_pchar_descriptor()
3182 {
3183 static int init = 0;
3184 static swig_type_info* info = 0;
3185 if (!init) {
3186 info = SWIG_TypeQuery("_p_char");
3187 init = 1;
3188 }
3189 return info;
3190 }
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3195 {
3196 if (carray) {
3197 if (size > INT_MAX) {
3198 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3199 return pchar_descriptor ?
3200 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3201 } else {
3202 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3203 }
3204 } else {
3205 return SWIG_Py_Void();
3206 }
3207 }
3208
3209
3210 SWIGINTERNINLINE PyObject *
3211 SWIG_From_char (char c)
3212 {
3213 return SWIG_FromCharPtrAndSize(&c,1);
3214 }
3215
3216
3217 SWIGINTERNINLINE PyObject*
3218 SWIG_From_unsigned_SS_long (unsigned long value)
3219 {
3220 return (value > LONG_MAX) ?
3221 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3234 {
3235 if (PyString_Check(obj)) {
3236 char *cstr; Py_ssize_t len;
3237 PyString_AsStringAndSize(obj, &cstr, &len);
3238 if (cptr) {
3239 if (alloc) {
3240 /*
3241 In python the user should not be able to modify the inner
3242 string representation. To warranty that, if you define
3243 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3244 buffer is always returned.
3245
3246 The default behavior is just to return the pointer value,
3247 so, be careful.
3248 */
3249 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3250 if (*alloc != SWIG_OLDOBJ)
3251 #else
3252 if (*alloc == SWIG_NEWOBJ)
3253 #endif
3254 {
3255 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3256 *alloc = SWIG_NEWOBJ;
3257 }
3258 else {
3259 *cptr = cstr;
3260 *alloc = SWIG_OLDOBJ;
3261 }
3262 } else {
3263 *cptr = PyString_AsString(obj);
3264 }
3265 }
3266 if (psize) *psize = len + 1;
3267 return SWIG_OK;
3268 } else {
3269 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3270 if (pchar_descriptor) {
3271 void* vptr = 0;
3272 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3273 if (cptr) *cptr = (char *) vptr;
3274 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3275 if (alloc) *alloc = SWIG_OLDOBJ;
3276 return SWIG_OK;
3277 }
3278 }
3279 }
3280 return SWIG_TypeError;
3281 }
3282
3283
3284 SWIGINTERN int
3285 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3286 {
3287 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3288 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3289 if (SWIG_IsOK(res)) {
3290 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3291 if (csize <= size) {
3292 if (val) {
3293 if (csize) memcpy(val, cptr, csize*sizeof(char));
3294 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3295 }
3296 if (alloc == SWIG_NEWOBJ) {
3297 delete[] cptr;
3298 res = SWIG_DelNewMask(res);
3299 }
3300 return res;
3301 }
3302 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3303 }
3304 return SWIG_TypeError;
3305 }
3306
3307
3308 SWIGINTERN int
3309 SWIG_AsVal_char (PyObject * obj, char *val)
3310 {
3311 int res = SWIG_AsCharArray(obj, val, 1);
3312 if (!SWIG_IsOK(res)) {
3313 long v;
3314 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3315 if (SWIG_IsOK(res)) {
3316 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3317 if (val) *val = static_cast< char >(v);
3318 } else {
3319 res = SWIG_OverflowError;
3320 }
3321 }
3322 }
3323 return res;
3324 }
3325
3326 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3327 // We use only strings for the streams, not unicode
3328 PyObject* str = PyObject_Str(obj);
3329 if (! str) {
3330 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3331 return;
3332 }
3333 self->Write(PyString_AS_STRING(str),
3334 PyString_GET_SIZE(str));
3335 Py_DECREF(str);
3336 }
3337
3338 #include "wx/wxPython/pyistream.h"
3339
3340
3341 class wxPyFileSystemHandler : public wxFileSystemHandler
3342 {
3343 public:
3344 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3345
3346 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3347 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3348 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3349 DEC_PYCALLBACK_STRING__pure(FindNext);
3350
3351 wxString GetProtocol(const wxString& location) {
3352 return wxFileSystemHandler::GetProtocol(location);
3353 }
3354
3355 wxString GetLeftLocation(const wxString& location) {
3356 return wxFileSystemHandler::GetLeftLocation(location);
3357 }
3358
3359 wxString GetAnchor(const wxString& location) {
3360 return wxFileSystemHandler::GetAnchor(location);
3361 }
3362
3363 wxString GetRightLocation(const wxString& location) {
3364 return wxFileSystemHandler::GetRightLocation(location);
3365 }
3366
3367 wxString GetMimeTypeFromExt(const wxString& location) {
3368 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3369 }
3370
3371 PYPRIVATE;
3372 };
3373
3374
3375 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3376 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3377 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3378 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3379
3380
3381 SWIGINTERN int
3382 SWIG_AsVal_bool (PyObject *obj, bool *val)
3383 {
3384 if (obj == Py_True) {
3385 if (val) *val = true;
3386 return SWIG_OK;
3387 } else if (obj == Py_False) {
3388 if (val) *val = false;
3389 return SWIG_OK;
3390 } else {
3391 long v = 0;
3392 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3393 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3394 return res;
3395 }
3396 }
3397
3398 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3399 wxFileName fname = wxFileSystem::URLToFileName(url);
3400 return fname.GetFullPath();
3401 }
3402
3403 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3404 wxImage& image,
3405 long type) {
3406 wxMemoryFSHandler::AddFile(filename, image, type);
3407 }
3408
3409 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3410 const wxBitmap& bitmap,
3411 long type) {
3412 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3413 }
3414
3415 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3416 PyObject* data) {
3417 if (! PyString_Check(data)) {
3418 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3419 "Expected string object"));
3420 return;
3421 }
3422
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 void* ptr = (void*)PyString_AsString(data);
3425 size_t size = PyString_Size(data);
3426 wxPyEndBlockThreads(blocked);
3427
3428 wxMemoryFSHandler::AddFile(filename, ptr, size);
3429 }
3430
3431
3432 #include "wx/wxPython/pyistream.h"
3433
3434
3435 SWIGINTERN int
3436 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3437 {
3438 long v = 0;
3439 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3440 return SWIG_TypeError;
3441 }
3442 else if (val)
3443 *val = (unsigned long)v;
3444 return SWIG_OK;
3445 }
3446
3447
3448 SWIGINTERN int
3449 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3450 {
3451 unsigned long v;
3452 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3453 if (SWIG_IsOK(res)) {
3454 if ((v > UCHAR_MAX)) {
3455 return SWIG_OverflowError;
3456 } else {
3457 if (val) *val = static_cast< unsigned char >(v);
3458 }
3459 }
3460 return res;
3461 }
3462
3463
3464 SWIGINTERNINLINE PyObject *
3465 SWIG_From_unsigned_SS_char (unsigned char value)
3466 {
3467 return SWIG_From_unsigned_SS_long (value);
3468 }
3469
3470 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3471 wxImageHistogramEntry e = (*self)[key];
3472 return e.value;
3473 }
3474 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3475 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3476 wxImageHistogramEntry e = (*self)[key];
3477 return e.value;
3478 }
3479 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3480 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3481 colour.Green(),
3482 colour.Blue());
3483 wxImageHistogramEntry e = (*self)[key];
3484 return e.value;
3485 }
3486
3487 // Pull the nested class out to the top level for SWIG's sake
3488 #define wxImage_RGBValue wxImage::RGBValue
3489 #define wxImage_HSVValue wxImage::HSVValue
3490
3491 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3492 if (width > 0 && height > 0)
3493 return new wxImage(width, height, clear);
3494 else
3495 return new wxImage;
3496 }
3497 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3498 return new wxImage(bitmap.ConvertToImage());
3499 }
3500 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3501 if (DATASIZE != width*height*3) {
3502 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3503 return NULL;
3504 }
3505
3506 // Copy the source data so the wxImage can clean it up later
3507 buffer copy = (buffer)malloc(DATASIZE);
3508 if (copy == NULL) {
3509 wxPyBLOCK_THREADS(PyErr_NoMemory());
3510 return NULL;
3511 }
3512 memcpy(copy, data, DATASIZE);
3513 return new wxImage(width, height, copy, false);
3514 }
3515 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3516 if (DATASIZE != width*height*3) {
3517 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3518 return NULL;
3519 }
3520 if (ALPHASIZE != width*height) {
3521 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3522 return NULL;
3523 }
3524
3525 // Copy the source data so the wxImage can clean it up later
3526 buffer dcopy = (buffer)malloc(DATASIZE);
3527 if (dcopy == NULL) {
3528 wxPyBLOCK_THREADS(PyErr_NoMemory());
3529 return NULL;
3530 }
3531 memcpy(dcopy, data, DATASIZE);
3532
3533 buffer acopy = (buffer)malloc(ALPHASIZE);
3534 if (acopy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return NULL;
3537 }
3538 memcpy(acopy, alpha, ALPHASIZE);
3539
3540 return new wxImage(width, height, dcopy, acopy, false);
3541 }
3542 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3543 wxSize size(self->GetWidth(), self->GetHeight());
3544 return size;
3545 }
3546 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3547 buffer data = self->GetData();
3548 int len = self->GetWidth() * self->GetHeight() * 3;
3549 PyObject* rv;
3550 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3551 return rv;
3552 }
3553 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3554 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3555 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3556 return;
3557 }
3558 buffer copy = (buffer)malloc(DATASIZE);
3559 if (copy == NULL) {
3560 wxPyBLOCK_THREADS(PyErr_NoMemory());
3561 return;
3562 }
3563 memcpy(copy, data, DATASIZE);
3564 self->SetData(copy, false);
3565 // wxImage takes ownership of copy...
3566 }
3567 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3568 buffer data = self->GetData();
3569 int len = self->GetWidth() * self->GetHeight() * 3;
3570 PyObject* rv;
3571 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3572 return rv;
3573 }
3574 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3575 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3577 return;
3578 }
3579 self->SetData(data, true);
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 if (! data) {
3584 RETURN_NONE();
3585 } else {
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3589 return rv;
3590 }
3591 }
3592 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3593 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3595 return;
3596 }
3597 buffer acopy = (buffer)malloc(ALPHASIZE);
3598 if (acopy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(acopy, alpha, ALPHASIZE);
3603 self->SetAlpha(acopy, false);
3604 // wxImage takes ownership of acopy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3607 buffer data = self->GetAlpha();
3608 int len = self->GetWidth() * self->GetHeight();
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3614 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3616 return;
3617 }
3618 self->SetAlpha(alpha, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetHandlers(){
3621 wxList& list = wxImage::GetHandlers();
3622 return wxPy_ConvertList(&list);
3623 }
3624 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3625 wxBitmap bitmap(*self, depth);
3626 return bitmap;
3627 }
3628 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3629 wxImage mono = self->ConvertToMono( red, green, blue );
3630 wxBitmap bitmap( mono, 1 );
3631 return bitmap;
3632 }
3633
3634 wxImage* _ImageFromBuffer(int width, int height,
3635 buffer data, int DATASIZE,
3636 buffer alpha=NULL, int ALPHASIZE=0)
3637 {
3638 if (DATASIZE != width*height*3) {
3639 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3640 return NULL;
3641 }
3642 if (alpha != NULL) {
3643 if (ALPHASIZE != width*height) {
3644 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3645 return NULL;
3646 }
3647 return new wxImage(width, height, data, alpha, true);
3648 }
3649 return new wxImage(width, height, data, true);
3650 }
3651
3652 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3653 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3660 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3661 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3662 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3663 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3664 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3665 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3666 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3667
3668 #include <wx/quantize.h>
3669
3670 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3671 return wxQuantize::Quantize(src, dest,
3672 //NULL, // palette
3673 desiredNoColours,
3674 NULL, // eightBitData
3675 flags);
3676 }
3677 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3678 if (PyCallable_Check(func)) {
3679 self->Connect(id, lastId, eventType,
3680 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3681 new wxPyCallback(func));
3682 }
3683 else if (func == Py_None) {
3684 self->Disconnect(id, lastId, eventType,
3685 (wxObjectEventFunction)
3686 &wxPyCallback::EventThunker);
3687 }
3688 else {
3689 wxPyBLOCK_THREADS(
3690 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3691 }
3692 }
3693 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3694 return self->Disconnect(id, lastId, eventType,
3695 (wxObjectEventFunction)
3696 &wxPyCallback::EventThunker);
3697 }
3698 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3699 if (_self && _self != Py_None) {
3700 self->SetClientObject(new wxPyOORClientData(_self, incref));
3701 }
3702 else {
3703 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3704 if (data) {
3705 self->SetClientObject(NULL); // This will delete it too
3706 }
3707 }
3708 }
3709
3710 #if ! wxUSE_HOTKEY
3711 #define wxEVT_HOTKEY -9999
3712 #endif
3713
3714 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3715 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3716 if (data) {
3717 Py_INCREF(data->m_obj);
3718 return data->m_obj;
3719 } else {
3720 Py_INCREF(Py_None);
3721 return Py_None;
3722 }
3723 }
3724 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3725 wxPyClientData* data = new wxPyClientData(clientData);
3726 self->SetClientObject(data);
3727 }
3728 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3729 #if wxUSE_UNICODE
3730 return self->GetUnicodeKey();
3731 #else
3732 return 0;
3733 #endif
3734 }
3735 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3736 #if wxUSE_UNICODE
3737 self->m_uniChar = uniChar;
3738 #endif
3739 }
3740
3741 SWIGINTERNINLINE PyObject *
3742 SWIG_From_unsigned_SS_int (unsigned int value)
3743 {
3744 return SWIG_From_unsigned_SS_long (value);
3745 }
3746
3747
3748 SWIGINTERN int
3749 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3750 {
3751 unsigned long v;
3752 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3753 if (SWIG_IsOK(res)) {
3754 if ((v > UINT_MAX)) {
3755 return SWIG_OverflowError;
3756 } else {
3757 if (val) *val = static_cast< unsigned int >(v);
3758 }
3759 }
3760 return res;
3761 }
3762
3763 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3764 self->m_size = size;
3765 }
3766 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3767 int count = self->GetNumberOfFiles();
3768 wxString* files = self->GetFiles();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 PyObject* list = PyList_New(count);
3771
3772 if (!list) {
3773 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3774 wxPyEndBlockThreads(blocked);
3775 return NULL;
3776 }
3777
3778 for (int i=0; i<count; i++) {
3779 PyList_SetItem(list, i, wx2PyString(files[i]));
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return list;
3783 }
3784
3785
3786 SWIGINTERN wxPyApp *new_wxPyApp(){
3787 wxPythonApp = new wxPyApp();
3788 return wxPythonApp;
3789 }
3790 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3791 SWIGINTERN bool wxPyApp_DisplayAvailable(){
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 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3866
3867 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3868 return wxWindow::FindWindowById(id, parent);
3869 }
3870
3871 wxWindow* wxFindWindowByName( const wxString& name,
3872 const wxWindow *parent = NULL ) {
3873 return wxWindow::FindWindowByName(name, parent);
3874 }
3875
3876 wxWindow* wxFindWindowByLabel( const wxString& label,
3877 const wxWindow *parent = NULL ) {
3878 return wxWindow::FindWindowByLabel(label, parent);
3879 }
3880
3881
3882 #ifdef __WXMSW__
3883 #include <wx/msw/private.h> // to get wxGetWindowId
3884 #endif
3885
3886
3887 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3888 #ifdef __WXMSW__
3889 WXHWND hWnd = (WXHWND)_hWnd;
3890 long id = wxGetWindowId(hWnd);
3891 wxWindow* win = new wxWindow;
3892 if (parent)
3893 parent->AddChild(win);
3894 win->SetEventHandler(win);
3895 win->SetHWND(hWnd);
3896 win->SetId(id);
3897 win->SubclassWin(hWnd);
3898 win->AdoptAttributesFromHWND();
3899 win->SetupColours();
3900 return win;
3901 #else
3902 wxPyRaiseNotImplemented();
3903 return NULL;
3904 #endif
3905 }
3906
3907
3908 PyObject* GetTopLevelWindows() {
3909 return wxPy_ConvertList(&wxTopLevelWindows);
3910 }
3911
3912
3913 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3916
3917 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3918
3919
3920 SWIGINTERNINLINE int
3921 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3922 {
3923 unsigned long v;
3924 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3925 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3926 return res;
3927 }
3928
3929 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3930 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3931 wxMenuItemList& list = self->GetMenuItems();
3932 return wxPy_ConvertList(&list);
3933 }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) 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_Deflate" "', 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_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 (arg1)->DetachStream();
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_Py_Void();
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9893 PyObject *resultobj = 0;
9894 wxFSFile *arg1 = (wxFSFile *) 0 ;
9895 wxString *result = 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9905 }
9906 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 {
9910 wxString const &_result_ref = (arg1)->GetMimeType();
9911 result = (wxString *) &_result_ref;
9912 }
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *resultobj = 0;
9931 wxFSFile *arg1 = (wxFSFile *) 0 ;
9932 wxString *result = 0 ;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 PyObject *swig_obj[1] ;
9936
9937 if (!args) SWIG_fail;
9938 swig_obj[0] = args;
9939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9942 }
9943 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 {
9947 wxString const &_result_ref = (arg1)->GetLocation();
9948 result = (wxString *) &_result_ref;
9949 }
9950 wxPyEndAllowThreads(__tstate);
9951 if (PyErr_Occurred()) SWIG_fail;
9952 }
9953 {
9954 #if wxUSE_UNICODE
9955 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9956 #else
9957 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9958 #endif
9959 }
9960 return resultobj;
9961 fail:
9962 return NULL;
9963 }
9964
9965
9966 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9967 PyObject *resultobj = 0;
9968 wxFSFile *arg1 = (wxFSFile *) 0 ;
9969 wxString *result = 0 ;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 PyObject *swig_obj[1] ;
9973
9974 if (!args) SWIG_fail;
9975 swig_obj[0] = args;
9976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9979 }
9980 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 {
9984 wxString const &_result_ref = (arg1)->GetAnchor();
9985 result = (wxString *) &_result_ref;
9986 }
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 {
9991 #if wxUSE_UNICODE
9992 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9993 #else
9994 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9995 #endif
9996 }
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *resultobj = 0;
10005 wxFSFile *arg1 = (wxFSFile *) 0 ;
10006 wxDateTime result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 PyObject *swig_obj[1] ;
10010
10011 if (!args) SWIG_fail;
10012 swig_obj[0] = args;
10013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10014 if (!SWIG_IsOK(res1)) {
10015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10016 }
10017 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (arg1)->GetModificationTime();
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10032 PyObject *obj;
10033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10034 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10035 return SWIG_Py_Void();
10036 }
10037
10038 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 return SWIG_Python_InitShadowInstance(args);
10040 }
10041
10042 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 PyObject *swig_obj[1] ;
10048
10049 if (!args) SWIG_fail;
10050 swig_obj[0] = args;
10051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10054 }
10055 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 delete arg1;
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 resultobj = SWIG_Py_Void();
10064 return resultobj;
10065 fail:
10066 return NULL;
10067 }
10068
10069
10070 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10071 PyObject *obj;
10072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10073 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10074 return SWIG_Py_Void();
10075 }
10076
10077 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10078 PyObject *resultobj = 0;
10079 wxPyFileSystemHandler *result = 0 ;
10080
10081 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10098 PyObject *arg2 = (PyObject *) 0 ;
10099 PyObject *arg3 = (PyObject *) 0 ;
10100 void *argp1 = 0 ;
10101 int res1 = 0 ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 PyObject * obj2 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "self",(char *) "self",(char *) "_class", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10113 }
10114 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10115 arg2 = obj1;
10116 arg3 = obj2;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->_setCallbackInfo(arg2,arg3);
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_Py_Void();
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = 0;
10132 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10133 wxString *arg2 = 0 ;
10134 bool result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 bool temp2 = false ;
10138 PyObject * obj0 = 0 ;
10139 PyObject * obj1 = 0 ;
10140 char * kwnames[] = {
10141 (char *) "self",(char *) "location", NULL
10142 };
10143
10144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10148 }
10149 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10150 {
10151 arg2 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 {
10162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10163 }
10164 {
10165 if (temp2)
10166 delete arg2;
10167 }
10168 return resultobj;
10169 fail:
10170 {
10171 if (temp2)
10172 delete arg2;
10173 }
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10181 wxFileSystem *arg2 = 0 ;
10182 wxString *arg3 = 0 ;
10183 wxFSFile *result = 0 ;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 void *argp2 = 0 ;
10187 int res2 = 0 ;
10188 bool temp3 = false ;
10189 PyObject * obj0 = 0 ;
10190 PyObject * obj1 = 0 ;
10191 PyObject * obj2 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "fs",(char *) "location", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10203 if (!SWIG_IsOK(res2)) {
10204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10205 }
10206 if (!argp2) {
10207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10208 }
10209 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10210 {
10211 arg3 = wxString_in_helper(obj2);
10212 if (arg3 == NULL) SWIG_fail;
10213 temp3 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10223 }
10224 {
10225 if (temp3)
10226 delete arg3;
10227 }
10228 return resultobj;
10229 fail:
10230 {
10231 if (temp3)
10232 delete arg3;
10233 }
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj = 0;
10240 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10241 wxString *arg2 = 0 ;
10242 int arg3 = (int) 0 ;
10243 wxString result;
10244 void *argp1 = 0 ;
10245 int res1 = 0 ;
10246 bool temp2 = false ;
10247 int val3 ;
10248 int ecode3 = 0 ;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 PyObject * obj2 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "spec",(char *) "flags", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 if (obj2) {
10268 ecode3 = SWIG_AsVal_int(obj2, &val3);
10269 if (!SWIG_IsOK(ecode3)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10271 }
10272 arg3 = static_cast< int >(val3);
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 PyObject *swig_obj[1] ;
10308
10309 if (!args) SWIG_fail;
10310 swig_obj[0] = args;
10311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 result = (arg1)->FindNext();
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 {
10323 #if wxUSE_UNICODE
10324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10325 #else
10326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10327 #endif
10328 }
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj = 0;
10337 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10338 wxString *arg2 = 0 ;
10339 wxString result;
10340 void *argp1 = 0 ;
10341 int res1 = 0 ;
10342 bool temp2 = false ;
10343 PyObject * obj0 = 0 ;
10344 PyObject * obj1 = 0 ;
10345 char * kwnames[] = {
10346 (char *) "self",(char *) "location", NULL
10347 };
10348
10349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10353 }
10354 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10355 {
10356 arg2 = wxString_in_helper(obj1);
10357 if (arg2 == NULL) SWIG_fail;
10358 temp2 = true;
10359 }
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (arg1)->GetProtocol((wxString const &)*arg2);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 #if wxUSE_UNICODE
10368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10369 #else
10370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10371 #endif
10372 }
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return resultobj;
10378 fail:
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10388 PyObject *resultobj = 0;
10389 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10390 wxString *arg2 = 0 ;
10391 wxString result;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 bool temp2 = false ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397 char * kwnames[] = {
10398 (char *) "self",(char *) "location", NULL
10399 };
10400
10401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10405 }
10406 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 {
10419 #if wxUSE_UNICODE
10420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10421 #else
10422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10423 #endif
10424 }
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return resultobj;
10430 fail:
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj = 0;
10441 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10442 wxString *arg2 = 0 ;
10443 wxString result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 bool temp2 = false ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char * kwnames[] = {
10450 (char *) "self",(char *) "location", NULL
10451 };
10452
10453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10457 }
10458 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10459 {
10460 arg2 = wxString_in_helper(obj1);
10461 if (arg2 == NULL) SWIG_fail;
10462 temp2 = true;
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (arg1)->GetAnchor((wxString const &)*arg2);
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 #if wxUSE_UNICODE
10472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10473 #else
10474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10475 #endif
10476 }
10477 {
10478 if (temp2)
10479 delete arg2;
10480 }
10481 return resultobj;
10482 fail:
10483 {
10484 if (temp2)
10485 delete arg2;
10486 }
10487 return NULL;
10488 }
10489
10490
10491 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj = 0;
10493 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10494 wxString *arg2 = 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 PyObject * obj0 = 0 ;
10500 PyObject * obj1 = 0 ;
10501 char * kwnames[] = {
10502 (char *) "self",(char *) "location", NULL
10503 };
10504
10505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10507 if (!SWIG_IsOK(res1)) {
10508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10509 }
10510 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10511 {
10512 arg2 = wxString_in_helper(obj1);
10513 if (arg2 == NULL) SWIG_fail;
10514 temp2 = true;
10515 }
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10519 wxPyEndAllowThreads(__tstate);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 {
10523 #if wxUSE_UNICODE
10524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10525 #else
10526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10527 #endif
10528 }
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return resultobj;
10534 fail:
10535 {
10536 if (temp2)
10537 delete arg2;
10538 }
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10544 PyObject *resultobj = 0;
10545 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10546 wxString *arg2 = 0 ;
10547 wxString result;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 bool temp2 = false ;
10551 PyObject * obj0 = 0 ;
10552 PyObject * obj1 = 0 ;
10553 char * kwnames[] = {
10554 (char *) "self",(char *) "location", NULL
10555 };
10556
10557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10563 {
10564 arg2 = wxString_in_helper(obj1);
10565 if (arg2 == NULL) SWIG_fail;
10566 temp2 = true;
10567 }
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 {
10582 if (temp2)
10583 delete arg2;
10584 }
10585 return resultobj;
10586 fail:
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *obj;
10597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10598 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10599 return SWIG_Py_Void();
10600 }
10601
10602 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10603 return SWIG_Python_InitShadowInstance(args);
10604 }
10605
10606 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxFileSystem *result = 0 ;
10609
10610 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxFileSystem *)new wxFileSystem();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10619 }
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10629 void *argp1 = 0 ;
10630 int res1 = 0 ;
10631 PyObject *swig_obj[1] ;
10632
10633 if (!args) SWIG_fail;
10634 swig_obj[0] = args;
10635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10638 }
10639 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 delete arg1;
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_Py_Void();
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj = 0;
10656 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10657 wxString *arg2 = 0 ;
10658 bool arg3 = (bool) false ;
10659 void *argp1 = 0 ;
10660 int res1 = 0 ;
10661 bool temp2 = false ;
10662 bool val3 ;
10663 int ecode3 = 0 ;
10664 PyObject * obj0 = 0 ;
10665 PyObject * obj1 = 0 ;
10666 PyObject * obj2 = 0 ;
10667 char * kwnames[] = {
10668 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10669 };
10670
10671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10673 if (!SWIG_IsOK(res1)) {
10674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10675 }
10676 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10677 {
10678 arg2 = wxString_in_helper(obj1);
10679 if (arg2 == NULL) SWIG_fail;
10680 temp2 = true;
10681 }
10682 if (obj2) {
10683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10684 if (!SWIG_IsOK(ecode3)) {
10685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10686 }
10687 arg3 = static_cast< bool >(val3);
10688 }
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_Py_Void();
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return resultobj;
10701 fail:
10702 {
10703 if (temp2)
10704 delete arg2;
10705 }
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 PyObject *resultobj = 0;
10712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10713 wxString result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 PyObject *swig_obj[1] ;
10717
10718 if (!args) SWIG_fail;
10719 swig_obj[0] = args;
10720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10723 }
10724 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (arg1)->GetPath();
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 #if wxUSE_UNICODE
10733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10734 #else
10735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10736 #endif
10737 }
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10747 wxString *arg2 = 0 ;
10748 wxFSFile *result = 0 ;
10749 void *argp1 = 0 ;
10750 int res1 = 0 ;
10751 bool temp2 = false ;
10752 PyObject * obj0 = 0 ;
10753 PyObject * obj1 = 0 ;
10754 char * kwnames[] = {
10755 (char *) "self",(char *) "location", NULL
10756 };
10757
10758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10760 if (!SWIG_IsOK(res1)) {
10761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10762 }
10763 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10764 {
10765 arg2 = wxString_in_helper(obj1);
10766 if (arg2 == NULL) SWIG_fail;
10767 temp2 = true;
10768 }
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10777 }
10778 {
10779 if (temp2)
10780 delete arg2;
10781 }
10782 return resultobj;
10783 fail:
10784 {
10785 if (temp2)
10786 delete arg2;
10787 }
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10795 wxString *arg2 = 0 ;
10796 int arg3 = (int) 0 ;
10797 wxString result;
10798 void *argp1 = 0 ;
10799 int res1 = 0 ;
10800 bool temp2 = false ;
10801 int val3 ;
10802 int ecode3 = 0 ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 PyObject * obj2 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "self",(char *) "spec",(char *) "flags", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10812 if (!SWIG_IsOK(res1)) {
10813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10814 }
10815 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 if (obj2) {
10822 ecode3 = SWIG_AsVal_int(obj2, &val3);
10823 if (!SWIG_IsOK(ecode3)) {
10824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10825 }
10826 arg3 = static_cast< int >(val3);
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 {
10835 #if wxUSE_UNICODE
10836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10837 #else
10838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10839 #endif
10840 }
10841 {
10842 if (temp2)
10843 delete arg2;
10844 }
10845 return resultobj;
10846 fail:
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10856 PyObject *resultobj = 0;
10857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10858 wxString result;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 PyObject *swig_obj[1] ;
10862
10863 if (!args) SWIG_fail;
10864 swig_obj[0] = args;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10868 }
10869 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (arg1)->FindNext();
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 #if wxUSE_UNICODE
10878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10879 #else
10880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10881 #endif
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10892 int res1 = 0 ;
10893 PyObject * obj0 = 0 ;
10894 char * kwnames[] = {
10895 (char *) "handler", NULL
10896 };
10897
10898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10899 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10900 if (!SWIG_IsOK(res1)) {
10901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10902 }
10903 {
10904 PyThreadState* __tstate = wxPyBeginAllowThreads();
10905 wxFileSystem::AddHandler(arg1);
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_Py_Void();
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj = 0;
10918 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10919 wxFileSystemHandler *result = 0 ;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 PyObject * obj0 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "handler", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10931 }
10932 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *resultobj = 0;
10948
10949 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 wxFileSystem::CleanUpHandlers();
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_Py_Void();
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxString *arg1 = 0 ;
10966 wxString result;
10967 bool temp1 = false ;
10968 PyObject * obj0 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "filename", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10974 {
10975 arg1 = wxString_in_helper(obj0);
10976 if (arg1 == NULL) SWIG_fail;
10977 temp1 = true;
10978 }
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 {
10986 #if wxUSE_UNICODE
10987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10988 #else
10989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10990 #endif
10991 }
10992 {
10993 if (temp1)
10994 delete arg1;
10995 }
10996 return resultobj;
10997 fail:
10998 {
10999 if (temp1)
11000 delete arg1;
11001 }
11002 return NULL;
11003 }
11004
11005
11006 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj = 0;
11008 wxString *arg1 = 0 ;
11009 wxString result;
11010 bool temp1 = false ;
11011 PyObject * obj0 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "url", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11017 {
11018 arg1 = wxString_in_helper(obj0);
11019 if (arg1 == NULL) SWIG_fail;
11020 temp1 = true;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 {
11029 #if wxUSE_UNICODE
11030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11031 #else
11032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11033 #endif
11034 }
11035 {
11036 if (temp1)
11037 delete arg1;
11038 }
11039 return resultobj;
11040 fail:
11041 {
11042 if (temp1)
11043 delete arg1;
11044 }
11045 return NULL;
11046 }
11047
11048
11049 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11050 PyObject *obj;
11051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11052 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11053 return SWIG_Py_Void();
11054 }
11055
11056 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 return SWIG_Python_InitShadowInstance(args);
11058 }
11059
11060 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11061 PyObject *resultobj = 0;
11062 wxInternetFSHandler *result = 0 ;
11063
11064 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj = 0;
11080 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11081 wxString *arg2 = 0 ;
11082 bool result;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 bool temp2 = false ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "location", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11096 }
11097 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11098 {
11099 arg2 = wxString_in_helper(obj1);
11100 if (arg2 == NULL) SWIG_fail;
11101 temp2 = true;
11102 }
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11111 }
11112 {
11113 if (temp2)
11114 delete arg2;
11115 }
11116 return resultobj;
11117 fail:
11118 {
11119 if (temp2)
11120 delete arg2;
11121 }
11122 return NULL;
11123 }
11124
11125
11126 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj = 0;
11128 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11129 wxFileSystem *arg2 = 0 ;
11130 wxString *arg3 = 0 ;
11131 wxFSFile *result = 0 ;
11132 void *argp1 = 0 ;
11133 int res1 = 0 ;
11134 void *argp2 = 0 ;
11135 int res2 = 0 ;
11136 bool temp3 = false ;
11137 PyObject * obj0 = 0 ;
11138 PyObject * obj1 = 0 ;
11139 PyObject * obj2 = 0 ;
11140 char * kwnames[] = {
11141 (char *) "self",(char *) "fs",(char *) "location", NULL
11142 };
11143
11144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11148 }
11149 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11151 if (!SWIG_IsOK(res2)) {
11152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11153 }
11154 if (!argp2) {
11155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11156 }
11157 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11158 {
11159 arg3 = wxString_in_helper(obj2);
11160 if (arg3 == NULL) SWIG_fail;
11161 temp3 = true;
11162 }
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 {
11170 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11171 }
11172 {
11173 if (temp3)
11174 delete arg3;
11175 }
11176 return resultobj;
11177 fail:
11178 {
11179 if (temp3)
11180 delete arg3;
11181 }
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *obj;
11188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11189 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11190 return SWIG_Py_Void();
11191 }
11192
11193 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11194 return SWIG_Python_InitShadowInstance(args);
11195 }
11196
11197 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199 wxZipFSHandler *result = 0 ;
11200
11201 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (wxZipFSHandler *)new wxZipFSHandler();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = 0;
11217 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11218 wxString *arg2 = 0 ;
11219 bool result;
11220 void *argp1 = 0 ;
11221 int res1 = 0 ;
11222 bool temp2 = false ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 char * kwnames[] = {
11226 (char *) "self",(char *) "location", NULL
11227 };
11228
11229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11231 if (!SWIG_IsOK(res1)) {
11232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11233 }
11234 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11235 {
11236 arg2 = wxString_in_helper(obj1);
11237 if (arg2 == NULL) SWIG_fail;
11238 temp2 = true;
11239 }
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 {
11247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11248 }
11249 {
11250 if (temp2)
11251 delete arg2;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp2)
11257 delete arg2;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11266 wxFileSystem *arg2 = 0 ;
11267 wxString *arg3 = 0 ;
11268 wxFSFile *result = 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 = 0 ;
11272 int res2 = 0 ;
11273 bool temp3 = false ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 char * kwnames[] = {
11278 (char *) "self",(char *) "fs",(char *) "location", NULL
11279 };
11280
11281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11285 }
11286 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11288 if (!SWIG_IsOK(res2)) {
11289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11290 }
11291 if (!argp2) {
11292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11293 }
11294 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11295 {
11296 arg3 = wxString_in_helper(obj2);
11297 if (arg3 == NULL) SWIG_fail;
11298 temp3 = true;
11299 }
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11308 }
11309 {
11310 if (temp3)
11311 delete arg3;
11312 }
11313 return resultobj;
11314 fail:
11315 {
11316 if (temp3)
11317 delete arg3;
11318 }
11319 return NULL;
11320 }
11321
11322
11323 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj = 0;
11325 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11326 wxString *arg2 = 0 ;
11327 int arg3 = (int) 0 ;
11328 wxString result;
11329 void *argp1 = 0 ;
11330 int res1 = 0 ;
11331 bool temp2 = false ;
11332 int val3 ;
11333 int ecode3 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "self",(char *) "spec",(char *) "flags", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11345 }
11346 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11347 {
11348 arg2 = wxString_in_helper(obj1);
11349 if (arg2 == NULL) SWIG_fail;
11350 temp2 = true;
11351 }
11352 if (obj2) {
11353 ecode3 = SWIG_AsVal_int(obj2, &val3);
11354 if (!SWIG_IsOK(ecode3)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11356 }
11357 arg3 = static_cast< int >(val3);
11358 }
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 {
11366 #if wxUSE_UNICODE
11367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11368 #else
11369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11370 #endif
11371 }
11372 {
11373 if (temp2)
11374 delete arg2;
11375 }
11376 return resultobj;
11377 fail:
11378 {
11379 if (temp2)
11380 delete arg2;
11381 }
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11389 wxString result;
11390 void *argp1 = 0 ;
11391 int res1 = 0 ;
11392 PyObject *swig_obj[1] ;
11393
11394 if (!args) SWIG_fail;
11395 swig_obj[0] = args;
11396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11399 }
11400 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (arg1)->FindNext();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 {
11408 #if wxUSE_UNICODE
11409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11410 #else
11411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11412 #endif
11413 }
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *obj;
11422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11423 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11424 return SWIG_Py_Void();
11425 }
11426
11427 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11428 return SWIG_Python_InitShadowInstance(args);
11429 }
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxImage *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "image",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11460 }
11461 arg2 = reinterpret_cast< wxImage * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 wxBitmap *arg2 = 0 ;
11492 long arg3 ;
11493 bool temp1 = false ;
11494 void *argp2 = 0 ;
11495 int res2 = 0 ;
11496 long val3 ;
11497 int ecode3 = 0 ;
11498 PyObject * obj0 = 0 ;
11499 PyObject * obj1 = 0 ;
11500 PyObject * obj2 = 0 ;
11501 char * kwnames[] = {
11502 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11503 };
11504
11505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11506 {
11507 arg1 = wxString_in_helper(obj0);
11508 if (arg1 == NULL) SWIG_fail;
11509 temp1 = true;
11510 }
11511 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11512 if (!SWIG_IsOK(res2)) {
11513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11514 }
11515 if (!argp2) {
11516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11517 }
11518 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11519 ecode3 = SWIG_AsVal_long(obj2, &val3);
11520 if (!SWIG_IsOK(ecode3)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11522 }
11523 arg3 = static_cast< long >(val3);
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 PyObject *arg2 = (PyObject *) 0 ;
11549 bool temp1 = false ;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "filename",(char *) "data", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11557 {
11558 arg1 = wxString_in_helper(obj0);
11559 if (arg1 == NULL) SWIG_fail;
11560 temp1 = true;
11561 }
11562 arg2 = obj1;
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_Py_Void();
11570 {
11571 if (temp1)
11572 delete arg1;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp1)
11578 delete arg1;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11585 PyObject *resultobj = 0;
11586 wxMemoryFSHandler *result = 0 ;
11587
11588 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = 0;
11604 wxString *arg1 = 0 ;
11605 bool temp1 = false ;
11606 PyObject * obj0 = 0 ;
11607 char * kwnames[] = {
11608 (char *) "filename", NULL
11609 };
11610
11611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11612 {
11613 arg1 = wxString_in_helper(obj0);
11614 if (arg1 == NULL) SWIG_fail;
11615 temp1 = true;
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 resultobj = SWIG_Py_Void();
11624 {
11625 if (temp1)
11626 delete arg1;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp1)
11632 delete arg1;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11639 PyObject *resultobj = 0;
11640 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11641 wxString *arg2 = 0 ;
11642 bool result;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 bool temp2 = false ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "location", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11656 }
11657 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11658 {
11659 arg2 = wxString_in_helper(obj1);
11660 if (arg2 == NULL) SWIG_fail;
11661 temp2 = true;
11662 }
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11671 }
11672 {
11673 if (temp2)
11674 delete arg2;
11675 }
11676 return resultobj;
11677 fail:
11678 {
11679 if (temp2)
11680 delete arg2;
11681 }
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj = 0;
11688 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11689 wxFileSystem *arg2 = 0 ;
11690 wxString *arg3 = 0 ;
11691 wxFSFile *result = 0 ;
11692 void *argp1 = 0 ;
11693 int res1 = 0 ;
11694 void *argp2 = 0 ;
11695 int res2 = 0 ;
11696 bool temp3 = false ;
11697 PyObject * obj0 = 0 ;
11698 PyObject * obj1 = 0 ;
11699 PyObject * obj2 = 0 ;
11700 char * kwnames[] = {
11701 (char *) "self",(char *) "fs",(char *) "location", NULL
11702 };
11703
11704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11708 }
11709 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11711 if (!SWIG_IsOK(res2)) {
11712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11713 }
11714 if (!argp2) {
11715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11716 }
11717 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11718 {
11719 arg3 = wxString_in_helper(obj2);
11720 if (arg3 == NULL) SWIG_fail;
11721 temp3 = true;
11722 }
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 {
11730 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11731 }
11732 {
11733 if (temp3)
11734 delete arg3;
11735 }
11736 return resultobj;
11737 fail:
11738 {
11739 if (temp3)
11740 delete arg3;
11741 }
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11747 PyObject *resultobj = 0;
11748 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11749 wxString *arg2 = 0 ;
11750 int arg3 = (int) 0 ;
11751 wxString result;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 bool temp2 = false ;
11755 int val3 ;
11756 int ecode3 = 0 ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 PyObject * obj2 = 0 ;
11760 char * kwnames[] = {
11761 (char *) "self",(char *) "spec",(char *) "flags", NULL
11762 };
11763
11764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11770 {
11771 arg2 = wxString_in_helper(obj1);
11772 if (arg2 == NULL) SWIG_fail;
11773 temp2 = true;
11774 }
11775 if (obj2) {
11776 ecode3 = SWIG_AsVal_int(obj2, &val3);
11777 if (!SWIG_IsOK(ecode3)) {
11778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11779 }
11780 arg3 = static_cast< int >(val3);
11781 }
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 #if wxUSE_UNICODE
11790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11791 #else
11792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11793 #endif
11794 }
11795 {
11796 if (temp2)
11797 delete arg2;
11798 }
11799 return resultobj;
11800 fail:
11801 {
11802 if (temp2)
11803 delete arg2;
11804 }
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11810 PyObject *resultobj = 0;
11811 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11812 wxString result;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815 PyObject *swig_obj[1] ;
11816
11817 if (!args) SWIG_fail;
11818 swig_obj[0] = args;
11819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11822 }
11823 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (arg1)->FindNext();
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 {
11831 #if wxUSE_UNICODE
11832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11833 #else
11834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11835 #endif
11836 }
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11844 PyObject *obj;
11845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11846 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11847 return SWIG_Py_Void();
11848 }
11849
11850 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 return SWIG_Python_InitShadowInstance(args);
11852 }
11853
11854 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 PyObject *resultobj = 0;
11856 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11857 wxString result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 PyObject *swig_obj[1] ;
11861
11862 if (!args) SWIG_fail;
11863 swig_obj[0] = args;
11864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11865 if (!SWIG_IsOK(res1)) {
11866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11867 }
11868 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (arg1)->GetName();
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 #if wxUSE_UNICODE
11877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11878 #else
11879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11880 #endif
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889 PyObject *resultobj = 0;
11890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11891 wxString result;
11892 void *argp1 = 0 ;
11893 int res1 = 0 ;
11894 PyObject *swig_obj[1] ;
11895
11896 if (!args) SWIG_fail;
11897 swig_obj[0] = args;
11898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11899 if (!SWIG_IsOK(res1)) {
11900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11901 }
11902 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (arg1)->GetExtension();
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 #if wxUSE_UNICODE
11911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11912 #else
11913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11914 #endif
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11923 PyObject *resultobj = 0;
11924 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11925 long result;
11926 void *argp1 = 0 ;
11927 int res1 = 0 ;
11928 PyObject *swig_obj[1] ;
11929
11930 if (!args) SWIG_fail;
11931 swig_obj[0] = args;
11932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (long)(arg1)->GetType();
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 resultobj = SWIG_From_long(static_cast< long >(result));
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 wxString result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11963 }
11964 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (arg1)->GetMimeType();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 #if wxUSE_UNICODE
11973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11974 #else
11975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11976 #endif
11977 }
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj = 0;
11986 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11987 wxString *arg2 = 0 ;
11988 bool result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 bool temp2 = false ;
11992 PyObject * obj0 = 0 ;
11993 PyObject * obj1 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "name", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (temp2)
12020 delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj = 0;
12034 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12035 wxInputStream *arg2 = 0 ;
12036 bool result;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 wxPyInputStream *temp2 ;
12040 bool created2 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "self",(char *) "stream", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12051 }
12052 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12053 {
12054 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12055 arg2 = temp2->m_wxis;
12056 created2 = false;
12057 } else {
12058 PyErr_Clear(); // clear the failure of the wxPyConvert above
12059 arg2 = wxPyCBInputStream_create(obj1, false);
12060 if (arg2 == NULL) {
12061 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12062 SWIG_fail;
12063 }
12064 created2 = true;
12065 }
12066 }
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (bool)(arg1)->CanRead(*arg2);
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12075 }
12076 {
12077 if (created2) delete arg2;
12078 }
12079 return resultobj;
12080 fail:
12081 {
12082 if (created2) delete arg2;
12083 }
12084 return NULL;
12085 }
12086
12087
12088 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj = 0;
12090 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12091 wxString *arg2 = 0 ;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 bool temp2 = false ;
12095 PyObject * obj0 = 0 ;
12096 PyObject * obj1 = 0 ;
12097 char * kwnames[] = {
12098 (char *) "self",(char *) "name", NULL
12099 };
12100
12101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12103 if (!SWIG_IsOK(res1)) {
12104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12105 }
12106 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12107 {
12108 arg2 = wxString_in_helper(obj1);
12109 if (arg2 == NULL) SWIG_fail;
12110 temp2 = true;
12111 }
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 (arg1)->SetName((wxString const &)*arg2);
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 resultobj = SWIG_Py_Void();
12119 {
12120 if (temp2)
12121 delete arg2;
12122 }
12123 return resultobj;
12124 fail:
12125 {
12126 if (temp2)
12127 delete arg2;
12128 }
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12136 wxString *arg2 = 0 ;
12137 void *argp1 = 0 ;
12138 int res1 = 0 ;
12139 bool temp2 = false ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 char * kwnames[] = {
12143 (char *) "self",(char *) "extension", NULL
12144 };
12145
12146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12148 if (!SWIG_IsOK(res1)) {
12149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12150 }
12151 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12152 {
12153 arg2 = wxString_in_helper(obj1);
12154 if (arg2 == NULL) SWIG_fail;
12155 temp2 = true;
12156 }
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 (arg1)->SetExtension((wxString const &)*arg2);
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_Py_Void();
12164 {
12165 if (temp2)
12166 delete arg2;
12167 }
12168 return resultobj;
12169 fail:
12170 {
12171 if (temp2)
12172 delete arg2;
12173 }
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12181 long arg2 ;
12182 void *argp1 = 0 ;
12183 int res1 = 0 ;
12184 long val2 ;
12185 int ecode2 = 0 ;
12186 PyObject * obj0 = 0 ;
12187 PyObject * obj1 = 0 ;
12188 char * kwnames[] = {
12189 (char *) "self",(char *) "type", NULL
12190 };
12191
12192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12194 if (!SWIG_IsOK(res1)) {
12195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12196 }
12197 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12198 ecode2 = SWIG_AsVal_long(obj1, &val2);
12199 if (!SWIG_IsOK(ecode2)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12201 }
12202 arg2 = static_cast< long >(val2);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 (arg1)->SetType(arg2);
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12219 wxString *arg2 = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 bool temp2 = false ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "mimetype", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12235 {
12236 arg2 = wxString_in_helper(obj1);
12237 if (arg2 == NULL) SWIG_fail;
12238 temp2 = true;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->SetMimeType((wxString const &)*arg2);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 resultobj = SWIG_Py_Void();
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 return resultobj;
12252 fail:
12253 {
12254 if (temp2)
12255 delete arg2;
12256 }
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 PyObject *resultobj = 0;
12270 wxPyImageHandler *result = 0 ;
12271
12272 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (wxPyImageHandler *)new wxPyImageHandler();
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj = 0;
12288 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12289 PyObject *arg2 = (PyObject *) 0 ;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "self",(char *) "self", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12302 }
12303 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12304 arg2 = obj1;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 (arg1)->_SetSelf(arg2);
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 resultobj = SWIG_Py_Void();
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *obj;
12320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12322 return SWIG_Py_Void();
12323 }
12324
12325 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 return SWIG_Python_InitShadowInstance(args);
12327 }
12328
12329 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331 wxImageHistogram *result = 0 ;
12332
12333 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (wxImageHistogram *)new wxImageHistogram();
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj = 0;
12349 byte arg1 ;
12350 byte arg2 ;
12351 byte arg3 ;
12352 unsigned long result;
12353 unsigned char val1 ;
12354 int ecode1 = 0 ;
12355 unsigned char val2 ;
12356 int ecode2 = 0 ;
12357 unsigned char val3 ;
12358 int ecode3 = 0 ;
12359 PyObject * obj0 = 0 ;
12360 PyObject * obj1 = 0 ;
12361 PyObject * obj2 = 0 ;
12362 char * kwnames[] = {
12363 (char *) "r",(char *) "g",(char *) "b", NULL
12364 };
12365
12366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12367 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12368 if (!SWIG_IsOK(ecode1)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12370 }
12371 arg1 = static_cast< byte >(val1);
12372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12373 if (!SWIG_IsOK(ecode2)) {
12374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12375 }
12376 arg2 = static_cast< byte >(val2);
12377 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12378 if (!SWIG_IsOK(ecode3)) {
12379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12380 }
12381 arg3 = static_cast< byte >(val3);
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj = 0;
12397 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12398 byte *arg2 = (byte *) 0 ;
12399 byte *arg3 = (byte *) 0 ;
12400 byte *arg4 = (byte *) 0 ;
12401 byte arg5 = (byte) 1 ;
12402 byte arg6 = (byte) 0 ;
12403 byte arg7 = (byte) 0 ;
12404 bool result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 byte temp2 ;
12408 int res2 = SWIG_TMPOBJ ;
12409 byte temp3 ;
12410 int res3 = SWIG_TMPOBJ ;
12411 byte temp4 ;
12412 int res4 = SWIG_TMPOBJ ;
12413 unsigned char val5 ;
12414 int ecode5 = 0 ;
12415 unsigned char val6 ;
12416 int ecode6 = 0 ;
12417 unsigned char val7 ;
12418 int ecode7 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 PyObject * obj3 = 0 ;
12423 char * kwnames[] = {
12424 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12425 };
12426
12427 arg2 = &temp2;
12428 arg3 = &temp3;
12429 arg4 = &temp4;
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12436 if (obj1) {
12437 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12438 if (!SWIG_IsOK(ecode5)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12440 }
12441 arg5 = static_cast< byte >(val5);
12442 }
12443 if (obj2) {
12444 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12445 if (!SWIG_IsOK(ecode6)) {
12446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12447 }
12448 arg6 = static_cast< byte >(val6);
12449 }
12450 if (obj3) {
12451 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12452 if (!SWIG_IsOK(ecode7)) {
12453 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12454 }
12455 arg7 = static_cast< byte >(val7);
12456 }
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 if (SWIG_IsTmpObj(res2)) {
12467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12468 } else {
12469 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12471 }
12472 if (SWIG_IsTmpObj(res3)) {
12473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12474 } else {
12475 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12477 }
12478 if (SWIG_IsTmpObj(res4)) {
12479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12480 } else {
12481 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12483 }
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj = 0;
12492 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12493 unsigned long arg2 ;
12494 unsigned long result;
12495 void *argp1 = 0 ;
12496 int res1 = 0 ;
12497 unsigned long val2 ;
12498 int ecode2 = 0 ;
12499 PyObject * obj0 = 0 ;
12500 PyObject * obj1 = 0 ;
12501 char * kwnames[] = {
12502 (char *) "self",(char *) "key", NULL
12503 };
12504
12505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12507 if (!SWIG_IsOK(res1)) {
12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12509 }
12510 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12511 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12512 if (!SWIG_IsOK(ecode2)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12514 }
12515 arg2 = static_cast< unsigned long >(val2);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 byte arg2 ;
12533 byte arg3 ;
12534 byte arg4 ;
12535 unsigned long result;
12536 void *argp1 = 0 ;
12537 int res1 = 0 ;
12538 unsigned char val2 ;
12539 int ecode2 = 0 ;
12540 unsigned char val3 ;
12541 int ecode3 = 0 ;
12542 unsigned char val4 ;
12543 int ecode4 = 0 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 PyObject * obj2 = 0 ;
12547 PyObject * obj3 = 0 ;
12548 char * kwnames[] = {
12549 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12550 };
12551
12552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12556 }
12557 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12558 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12559 if (!SWIG_IsOK(ecode2)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12561 }
12562 arg2 = static_cast< byte >(val2);
12563 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12564 if (!SWIG_IsOK(ecode3)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12566 }
12567 arg3 = static_cast< byte >(val3);
12568 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12569 if (!SWIG_IsOK(ecode4)) {
12570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12571 }
12572 arg4 = static_cast< byte >(val4);
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12580 return resultobj;
12581 fail:
12582 return NULL;
12583 }
12584
12585
12586 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12587 PyObject *resultobj = 0;
12588 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12589 wxColour *arg2 = 0 ;
12590 unsigned long result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 wxColour temp2 ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "self",(char *) "colour", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12602 if (!SWIG_IsOK(res1)) {
12603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12604 }
12605 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12606 {
12607 arg2 = &temp2;
12608 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 PyObject *obj;
12625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12626 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12627 return SWIG_Py_Void();
12628 }
12629
12630 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 return SWIG_Python_InitShadowInstance(args);
12632 }
12633
12634 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 byte arg1 = (byte) 0 ;
12637 byte arg2 = (byte) 0 ;
12638 byte arg3 = (byte) 0 ;
12639 wxImage_RGBValue *result = 0 ;
12640 unsigned char val1 ;
12641 int ecode1 = 0 ;
12642 unsigned char val2 ;
12643 int ecode2 = 0 ;
12644 unsigned char val3 ;
12645 int ecode3 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 PyObject * obj2 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "r",(char *) "g",(char *) "b", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12654 if (obj0) {
12655 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12656 if (!SWIG_IsOK(ecode1)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12658 }
12659 arg1 = static_cast< byte >(val1);
12660 }
12661 if (obj1) {
12662 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12663 if (!SWIG_IsOK(ecode2)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12665 }
12666 arg2 = static_cast< byte >(val2);
12667 }
12668 if (obj2) {
12669 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12670 if (!SWIG_IsOK(ecode3)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12672 }
12673 arg3 = static_cast< byte >(val3);
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12691 byte arg2 ;
12692 void *argp1 = 0 ;
12693 int res1 = 0 ;
12694 unsigned char val2 ;
12695 int ecode2 = 0 ;
12696 PyObject *swig_obj[2] ;
12697
12698 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12702 }
12703 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12704 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12705 if (!SWIG_IsOK(ecode2)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12707 }
12708 arg2 = static_cast< byte >(val2);
12709 if (arg1) (arg1)->red = arg2;
12710
12711 resultobj = SWIG_Py_Void();
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12719 PyObject *resultobj = 0;
12720 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12721 byte result;
12722 void *argp1 = 0 ;
12723 int res1 = 0 ;
12724 PyObject *swig_obj[1] ;
12725
12726 if (!args) SWIG_fail;
12727 swig_obj[0] = args;
12728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12733 result = (byte) ((arg1)->red);
12734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *resultobj = 0;
12743 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12744 byte arg2 ;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 unsigned char val2 ;
12748 int ecode2 = 0 ;
12749 PyObject *swig_obj[2] ;
12750
12751 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12755 }
12756 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12757 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12758 if (!SWIG_IsOK(ecode2)) {
12759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12760 }
12761 arg2 = static_cast< byte >(val2);
12762 if (arg1) (arg1)->green = arg2;
12763
12764 resultobj = SWIG_Py_Void();
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12774 byte result;
12775 void *argp1 = 0 ;
12776 int res1 = 0 ;
12777 PyObject *swig_obj[1] ;
12778
12779 if (!args) SWIG_fail;
12780 swig_obj[0] = args;
12781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12784 }
12785 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12786 result = (byte) ((arg1)->green);
12787 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12797 byte arg2 ;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 unsigned char val2 ;
12801 int ecode2 = 0 ;
12802 PyObject *swig_obj[2] ;
12803
12804 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12810 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12813 }
12814 arg2 = static_cast< byte >(val2);
12815 if (arg1) (arg1)->blue = arg2;
12816
12817 resultobj = SWIG_Py_Void();
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 PyObject *resultobj = 0;
12826 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12827 byte result;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 PyObject *swig_obj[1] ;
12831
12832 if (!args) SWIG_fail;
12833 swig_obj[0] = args;
12834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12835 if (!SWIG_IsOK(res1)) {
12836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12837 }
12838 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12839 result = (byte) ((arg1)->blue);
12840 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 PyObject *obj;
12849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12850 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12851 return SWIG_Py_Void();
12852 }
12853
12854 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 return SWIG_Python_InitShadowInstance(args);
12856 }
12857
12858 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj = 0;
12860 double arg1 = (double) 0.0 ;
12861 double arg2 = (double) 0.0 ;
12862 double arg3 = (double) 0.0 ;
12863 wxImage_HSVValue *result = 0 ;
12864 double val1 ;
12865 int ecode1 = 0 ;
12866 double val2 ;
12867 int ecode2 = 0 ;
12868 double val3 ;
12869 int ecode3 = 0 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "h",(char *) "s",(char *) "v", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12878 if (obj0) {
12879 ecode1 = SWIG_AsVal_double(obj0, &val1);
12880 if (!SWIG_IsOK(ecode1)) {
12881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12882 }
12883 arg1 = static_cast< double >(val1);
12884 }
12885 if (obj1) {
12886 ecode2 = SWIG_AsVal_double(obj1, &val2);
12887 if (!SWIG_IsOK(ecode2)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12889 }
12890 arg2 = static_cast< double >(val2);
12891 }
12892 if (obj2) {
12893 ecode3 = SWIG_AsVal_double(obj2, &val3);
12894 if (!SWIG_IsOK(ecode3)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12896 }
12897 arg3 = static_cast< double >(val3);
12898 }
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12915 double arg2 ;
12916 void *argp1 = 0 ;
12917 int res1 = 0 ;
12918 double val2 ;
12919 int ecode2 = 0 ;
12920 PyObject *swig_obj[2] ;
12921
12922 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12926 }
12927 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12928 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12931 }
12932 arg2 = static_cast< double >(val2);
12933 if (arg1) (arg1)->hue = arg2;
12934
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 PyObject *resultobj = 0;
12944 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12945 double result;
12946 void *argp1 = 0 ;
12947 int res1 = 0 ;
12948 PyObject *swig_obj[1] ;
12949
12950 if (!args) SWIG_fail;
12951 swig_obj[0] = args;
12952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12955 }
12956 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12957 result = (double) ((arg1)->hue);
12958 resultobj = SWIG_From_double(static_cast< double >(result));
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 PyObject *resultobj = 0;
12967 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12968 double arg2 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 double val2 ;
12972 int ecode2 = 0 ;
12973 PyObject *swig_obj[2] ;
12974
12975 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12977 if (!SWIG_IsOK(res1)) {
12978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12979 }
12980 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12981 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12982 if (!SWIG_IsOK(ecode2)) {
12983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12984 }
12985 arg2 = static_cast< double >(val2);
12986 if (arg1) (arg1)->saturation = arg2;
12987
12988 resultobj = SWIG_Py_Void();
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 PyObject *resultobj = 0;
12997 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12998 double result;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 PyObject *swig_obj[1] ;
13002
13003 if (!args) SWIG_fail;
13004 swig_obj[0] = args;
13005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13006 if (!SWIG_IsOK(res1)) {
13007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13008 }
13009 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13010 result = (double) ((arg1)->saturation);
13011 resultobj = SWIG_From_double(static_cast< double >(result));
13012 return resultobj;
13013 fail:
13014 return NULL;
13015 }
13016
13017
13018 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13019 PyObject *resultobj = 0;
13020 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13021 double arg2 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 double val2 ;
13025 int ecode2 = 0 ;
13026 PyObject *swig_obj[2] ;
13027
13028 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13030 if (!SWIG_IsOK(res1)) {
13031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13032 }
13033 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13034 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13035 if (!SWIG_IsOK(ecode2)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13037 }
13038 arg2 = static_cast< double >(val2);
13039 if (arg1) (arg1)->value = arg2;
13040
13041 resultobj = SWIG_Py_Void();
13042 return resultobj;
13043 fail:
13044 return NULL;
13045 }
13046
13047
13048 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13049 PyObject *resultobj = 0;
13050 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13051 double result;
13052 void *argp1 = 0 ;
13053 int res1 = 0 ;
13054 PyObject *swig_obj[1] ;
13055
13056 if (!args) SWIG_fail;
13057 swig_obj[0] = args;
13058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13059 if (!SWIG_IsOK(res1)) {
13060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13061 }
13062 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13063 result = (double) ((arg1)->value);
13064 resultobj = SWIG_From_double(static_cast< double >(result));
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *obj;
13073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13074 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13075 return SWIG_Py_Void();
13076 }
13077
13078 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 return SWIG_Python_InitShadowInstance(args);
13080 }
13081
13082 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj = 0;
13084 wxString *arg1 = 0 ;
13085 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13086 int arg3 = (int) -1 ;
13087 wxImage *result = 0 ;
13088 bool temp1 = false ;
13089 long val2 ;
13090 int ecode2 = 0 ;
13091 int val3 ;
13092 int ecode3 = 0 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 PyObject * obj2 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "name",(char *) "type",(char *) "index", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13101 {
13102 arg1 = wxString_in_helper(obj0);
13103 if (arg1 == NULL) SWIG_fail;
13104 temp1 = true;
13105 }
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_long(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13110 }
13111 arg2 = static_cast< long >(val2);
13112 }
13113 if (obj2) {
13114 ecode3 = SWIG_AsVal_int(obj2, &val3);
13115 if (!SWIG_IsOK(ecode3)) {
13116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13117 }
13118 arg3 = static_cast< int >(val3);
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13127 {
13128 if (temp1)
13129 delete arg1;
13130 }
13131 return resultobj;
13132 fail:
13133 {
13134 if (temp1)
13135 delete arg1;
13136 }
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142 PyObject *resultobj = 0;
13143 wxImage *arg1 = (wxImage *) 0 ;
13144 void *argp1 = 0 ;
13145 int res1 = 0 ;
13146 PyObject *swig_obj[1] ;
13147
13148 if (!args) SWIG_fail;
13149 swig_obj[0] = args;
13150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13153 }
13154 arg1 = reinterpret_cast< wxImage * >(argp1);
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 delete arg1;
13158
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 resultobj = SWIG_Py_Void();
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 wxString *arg1 = 0 ;
13172 wxString *arg2 = 0 ;
13173 int arg3 = (int) -1 ;
13174 wxImage *result = 0 ;
13175 bool temp1 = false ;
13176 bool temp2 = false ;
13177 int val3 ;
13178 int ecode3 = 0 ;
13179 PyObject * obj0 = 0 ;
13180 PyObject * obj1 = 0 ;
13181 PyObject * obj2 = 0 ;
13182 char * kwnames[] = {
13183 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13184 };
13185
13186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13187 {
13188 arg1 = wxString_in_helper(obj0);
13189 if (arg1 == NULL) SWIG_fail;
13190 temp1 = true;
13191 }
13192 {
13193 arg2 = wxString_in_helper(obj1);
13194 if (arg2 == NULL) SWIG_fail;
13195 temp2 = true;
13196 }
13197 if (obj2) {
13198 ecode3 = SWIG_AsVal_int(obj2, &val3);
13199 if (!SWIG_IsOK(ecode3)) {
13200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13201 }
13202 arg3 = static_cast< int >(val3);
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13211 {
13212 if (temp1)
13213 delete arg1;
13214 }
13215 {
13216 if (temp2)
13217 delete arg2;
13218 }
13219 return resultobj;
13220 fail:
13221 {
13222 if (temp1)
13223 delete arg1;
13224 }
13225 {
13226 if (temp2)
13227 delete arg2;
13228 }
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 wxInputStream *arg1 = 0 ;
13236 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13237 int arg3 = (int) -1 ;
13238 wxImage *result = 0 ;
13239 wxPyInputStream *temp1 ;
13240 bool created1 ;
13241 long val2 ;
13242 int ecode2 = 0 ;
13243 int val3 ;
13244 int ecode3 = 0 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 char * kwnames[] = {
13249 (char *) "stream",(char *) "type",(char *) "index", NULL
13250 };
13251
13252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13253 {
13254 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13255 arg1 = temp1->m_wxis;
13256 created1 = false;
13257 } else {
13258 PyErr_Clear(); // clear the failure of the wxPyConvert above
13259 arg1 = wxPyCBInputStream_create(obj0, false);
13260 if (arg1 == NULL) {
13261 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13262 SWIG_fail;
13263 }
13264 created1 = true;
13265 }
13266 }
13267 if (obj1) {
13268 ecode2 = SWIG_AsVal_long(obj1, &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13271 }
13272 arg2 = static_cast< long >(val2);
13273 }
13274 if (obj2) {
13275 ecode3 = SWIG_AsVal_int(obj2, &val3);
13276 if (!SWIG_IsOK(ecode3)) {
13277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13278 }
13279 arg3 = static_cast< int >(val3);
13280 }
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13288 {
13289 if (created1) delete arg1;
13290 }
13291 return resultobj;
13292 fail:
13293 {
13294 if (created1) delete arg1;
13295 }
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13301 PyObject *resultobj = 0;
13302 wxInputStream *arg1 = 0 ;
13303 wxString *arg2 = 0 ;
13304 int arg3 = (int) -1 ;
13305 wxImage *result = 0 ;
13306 wxPyInputStream *temp1 ;
13307 bool created1 ;
13308 bool temp2 = false ;
13309 int val3 ;
13310 int ecode3 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13319 {
13320 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13321 arg1 = temp1->m_wxis;
13322 created1 = false;
13323 } else {
13324 PyErr_Clear(); // clear the failure of the wxPyConvert above
13325 arg1 = wxPyCBInputStream_create(obj0, false);
13326 if (arg1 == NULL) {
13327 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13328 SWIG_fail;
13329 }
13330 created1 = true;
13331 }
13332 }
13333 {
13334 arg2 = wxString_in_helper(obj1);
13335 if (arg2 == NULL) SWIG_fail;
13336 temp2 = true;
13337 }
13338 if (obj2) {
13339 ecode3 = SWIG_AsVal_int(obj2, &val3);
13340 if (!SWIG_IsOK(ecode3)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13342 }
13343 arg3 = static_cast< int >(val3);
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13352 {
13353 if (created1) delete arg1;
13354 }
13355 {
13356 if (temp2)
13357 delete arg2;
13358 }
13359 return resultobj;
13360 fail:
13361 {
13362 if (created1) delete arg1;
13363 }
13364 {
13365 if (temp2)
13366 delete arg2;
13367 }
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj = 0;
13374 int arg1 = (int) 0 ;
13375 int arg2 = (int) 0 ;
13376 bool arg3 = (bool) true ;
13377 wxImage *result = 0 ;
13378 int val1 ;
13379 int ecode1 = 0 ;
13380 int val2 ;
13381 int ecode2 = 0 ;
13382 bool val3 ;
13383 int ecode3 = 0 ;
13384 PyObject * obj0 = 0 ;
13385 PyObject * obj1 = 0 ;
13386 PyObject * obj2 = 0 ;
13387 char * kwnames[] = {
13388 (char *) "width",(char *) "height",(char *) "clear", NULL
13389 };
13390
13391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13392 if (obj0) {
13393 ecode1 = SWIG_AsVal_int(obj0, &val1);
13394 if (!SWIG_IsOK(ecode1)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13396 }
13397 arg1 = static_cast< int >(val1);
13398 }
13399 if (obj1) {
13400 ecode2 = SWIG_AsVal_int(obj1, &val2);
13401 if (!SWIG_IsOK(ecode2)) {
13402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13403 }
13404 arg2 = static_cast< int >(val2);
13405 }
13406 if (obj2) {
13407 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13408 if (!SWIG_IsOK(ecode3)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13410 }
13411 arg3 = static_cast< bool >(val3);
13412 }
13413 {
13414 PyThreadState* __tstate = wxPyBeginAllowThreads();
13415 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13416 wxPyEndAllowThreads(__tstate);
13417 if (PyErr_Occurred()) SWIG_fail;
13418 }
13419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = 0;
13428 wxBitmap *arg1 = 0 ;
13429 wxImage *result = 0 ;
13430 void *argp1 = 0 ;
13431 int res1 = 0 ;
13432 PyObject * obj0 = 0 ;
13433 char * kwnames[] = {
13434 (char *) "bitmap", NULL
13435 };
13436
13437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13438 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13439 if (!SWIG_IsOK(res1)) {
13440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13441 }
13442 if (!argp1) {
13443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13444 }
13445 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13446 {
13447 if (!wxPyCheckForApp()) SWIG_fail;
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj = 0;
13462 int arg1 ;
13463 int arg2 ;
13464 buffer arg3 ;
13465 int arg4 ;
13466 wxImage *result = 0 ;
13467 int val1 ;
13468 int ecode1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 Py_ssize_t temp3 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 PyObject * obj2 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "width",(char *) "height",(char *) "data", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13480 ecode1 = SWIG_AsVal_int(obj0, &val1);
13481 if (!SWIG_IsOK(ecode1)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13483 }
13484 arg1 = static_cast< int >(val1);
13485 ecode2 = SWIG_AsVal_int(obj1, &val2);
13486 if (!SWIG_IsOK(ecode2)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13488 }
13489 arg2 = static_cast< int >(val2);
13490 {
13491 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13492 arg4 = (int)temp3;
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13501 return resultobj;
13502 fail:
13503 return NULL;
13504 }
13505
13506
13507 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj = 0;
13509 int arg1 ;
13510 int arg2 ;
13511 buffer arg3 ;
13512 int arg4 ;
13513 buffer arg5 ;
13514 int arg6 ;
13515 wxImage *result = 0 ;
13516 int val1 ;
13517 int ecode1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 Py_ssize_t temp3 ;
13521 Py_ssize_t temp5 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 PyObject * obj3 = 0 ;
13526 char * kwnames[] = {
13527 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13528 };
13529
13530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13531 ecode1 = SWIG_AsVal_int(obj0, &val1);
13532 if (!SWIG_IsOK(ecode1)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13534 }
13535 arg1 = static_cast< int >(val1);
13536 ecode2 = SWIG_AsVal_int(obj1, &val2);
13537 if (!SWIG_IsOK(ecode2)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13539 }
13540 arg2 = static_cast< int >(val2);
13541 {
13542 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13543 arg4 = (int)temp3;
13544 }
13545 {
13546 if (obj3 != Py_None) {
13547 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13548 arg6 = (int)temp5;
13549 }
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13565 PyObject *resultobj = 0;
13566 wxImage *arg1 = (wxImage *) 0 ;
13567 int arg2 ;
13568 int arg3 ;
13569 bool arg4 = (bool) true ;
13570 void *argp1 = 0 ;
13571 int res1 = 0 ;
13572 int val2 ;
13573 int ecode2 = 0 ;
13574 int val3 ;
13575 int ecode3 = 0 ;
13576 bool val4 ;
13577 int ecode4 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 ecode2 = SWIG_AsVal_int(obj1, &val2);
13593 if (!SWIG_IsOK(ecode2)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13595 }
13596 arg2 = static_cast< int >(val2);
13597 ecode3 = SWIG_AsVal_int(obj2, &val3);
13598 if (!SWIG_IsOK(ecode3)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13600 }
13601 arg3 = static_cast< int >(val3);
13602 if (obj3) {
13603 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13606 }
13607 arg4 = static_cast< bool >(val4);
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 (arg1)->Create(arg2,arg3,arg4);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_Py_Void();
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13634 }
13635 arg1 = reinterpret_cast< wxImage * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 (arg1)->Destroy();
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxImage *arg1 = (wxImage *) 0 ;
13652 int arg2 ;
13653 int arg3 ;
13654 SwigValueWrapper<wxImage > result;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 int val2 ;
13658 int ecode2 = 0 ;
13659 int val3 ;
13660 int ecode3 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 char * kwnames[] = {
13665 (char *) "self",(char *) "width",(char *) "height", NULL
13666 };
13667
13668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13670 if (!SWIG_IsOK(res1)) {
13671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13672 }
13673 arg1 = reinterpret_cast< wxImage * >(argp1);
13674 ecode2 = SWIG_AsVal_int(obj1, &val2);
13675 if (!SWIG_IsOK(ecode2)) {
13676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13677 }
13678 arg2 = static_cast< int >(val2);
13679 ecode3 = SWIG_AsVal_int(obj2, &val3);
13680 if (!SWIG_IsOK(ecode3)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13682 }
13683 arg3 = static_cast< int >(val3);
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (arg1)->Scale(arg2,arg3);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxImage *arg1 = (wxImage *) 0 ;
13700 int arg2 ;
13701 int arg3 ;
13702 SwigValueWrapper<wxImage > result;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 int val3 ;
13708 int ecode3 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 char * kwnames[] = {
13713 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13714 };
13715
13716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13718 if (!SWIG_IsOK(res1)) {
13719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13720 }
13721 arg1 = reinterpret_cast< wxImage * >(argp1);
13722 ecode2 = SWIG_AsVal_int(obj1, &val2);
13723 if (!SWIG_IsOK(ecode2)) {
13724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13725 }
13726 arg2 = static_cast< int >(val2);
13727 ecode3 = SWIG_AsVal_int(obj2, &val3);
13728 if (!SWIG_IsOK(ecode3)) {
13729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13730 }
13731 arg3 = static_cast< int >(val3);
13732 {
13733 PyThreadState* __tstate = wxPyBeginAllowThreads();
13734 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13735 wxPyEndAllowThreads(__tstate);
13736 if (PyErr_Occurred()) SWIG_fail;
13737 }
13738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13739 return resultobj;
13740 fail:
13741 return NULL;
13742 }
13743
13744
13745 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj = 0;
13747 wxImage *arg1 = (wxImage *) 0 ;
13748 int arg2 ;
13749 int arg3 ;
13750 wxImage *result = 0 ;
13751 void *argp1 = 0 ;
13752 int res1 = 0 ;
13753 int val2 ;
13754 int ecode2 = 0 ;
13755 int val3 ;
13756 int ecode3 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 char * kwnames[] = {
13761 (char *) "self",(char *) "width",(char *) "height", NULL
13762 };
13763
13764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13766 if (!SWIG_IsOK(res1)) {
13767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13768 }
13769 arg1 = reinterpret_cast< wxImage * >(argp1);
13770 ecode2 = SWIG_AsVal_int(obj1, &val2);
13771 if (!SWIG_IsOK(ecode2)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13773 }
13774 arg2 = static_cast< int >(val2);
13775 ecode3 = SWIG_AsVal_int(obj2, &val3);
13776 if (!SWIG_IsOK(ecode3)) {
13777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13778 }
13779 arg3 = static_cast< int >(val3);
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 {
13783 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13784 result = (wxImage *) &_result_ref;
13785 }
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13790 return resultobj;
13791 fail:
13792 return NULL;
13793 }
13794
13795
13796 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13797 PyObject *resultobj = 0;
13798 wxImage *arg1 = (wxImage *) 0 ;
13799 wxSize *arg2 = 0 ;
13800 wxPoint *arg3 = 0 ;
13801 int arg4 = (int) -1 ;
13802 int arg5 = (int) -1 ;
13803 int arg6 = (int) -1 ;
13804 wxImage *result = 0 ;
13805 void *argp1 = 0 ;
13806 int res1 = 0 ;
13807 wxSize temp2 ;
13808 wxPoint temp3 ;
13809 int val4 ;
13810 int ecode4 = 0 ;
13811 int val5 ;
13812 int ecode5 = 0 ;
13813 int val6 ;
13814 int ecode6 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 PyObject * obj3 = 0 ;
13819 PyObject * obj4 = 0 ;
13820 PyObject * obj5 = 0 ;
13821 char * kwnames[] = {
13822 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13823 };
13824
13825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13827 if (!SWIG_IsOK(res1)) {
13828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13829 }
13830 arg1 = reinterpret_cast< wxImage * >(argp1);
13831 {
13832 arg2 = &temp2;
13833 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13834 }
13835 {
13836 arg3 = &temp3;
13837 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13838 }
13839 if (obj3) {
13840 ecode4 = SWIG_AsVal_int(obj3, &val4);
13841 if (!SWIG_IsOK(ecode4)) {
13842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13843 }
13844 arg4 = static_cast< int >(val4);
13845 }
13846 if (obj4) {
13847 ecode5 = SWIG_AsVal_int(obj4, &val5);
13848 if (!SWIG_IsOK(ecode5)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13850 }
13851 arg5 = static_cast< int >(val5);
13852 }
13853 if (obj5) {
13854 ecode6 = SWIG_AsVal_int(obj5, &val6);
13855 if (!SWIG_IsOK(ecode6)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13857 }
13858 arg6 = static_cast< int >(val6);
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 {
13863 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13864 result = (wxImage *) &_result_ref;
13865 }
13866 wxPyEndAllowThreads(__tstate);
13867 if (PyErr_Occurred()) SWIG_fail;
13868 }
13869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13870 return resultobj;
13871 fail:
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxImage *arg1 = (wxImage *) 0 ;
13879 int arg2 ;
13880 int arg3 ;
13881 byte arg4 ;
13882 byte arg5 ;
13883 byte arg6 ;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 int val2 ;
13887 int ecode2 = 0 ;
13888 int val3 ;
13889 int ecode3 = 0 ;
13890 unsigned char val4 ;
13891 int ecode4 = 0 ;
13892 unsigned char val5 ;
13893 int ecode5 = 0 ;
13894 unsigned char val6 ;
13895 int ecode6 = 0 ;
13896 PyObject * obj0 = 0 ;
13897 PyObject * obj1 = 0 ;
13898 PyObject * obj2 = 0 ;
13899 PyObject * obj3 = 0 ;
13900 PyObject * obj4 = 0 ;
13901 PyObject * obj5 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13908 if (!SWIG_IsOK(res1)) {
13909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13910 }
13911 arg1 = reinterpret_cast< wxImage * >(argp1);
13912 ecode2 = SWIG_AsVal_int(obj1, &val2);
13913 if (!SWIG_IsOK(ecode2)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13915 }
13916 arg2 = static_cast< int >(val2);
13917 ecode3 = SWIG_AsVal_int(obj2, &val3);
13918 if (!SWIG_IsOK(ecode3)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13920 }
13921 arg3 = static_cast< int >(val3);
13922 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13923 if (!SWIG_IsOK(ecode4)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13925 }
13926 arg4 = static_cast< byte >(val4);
13927 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13928 if (!SWIG_IsOK(ecode5)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13930 }
13931 arg5 = static_cast< byte >(val5);
13932 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13933 if (!SWIG_IsOK(ecode6)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13935 }
13936 arg6 = static_cast< byte >(val6);
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 return resultobj;
13945 fail:
13946 return NULL;
13947 }
13948
13949
13950 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13951 PyObject *resultobj = 0;
13952 wxImage *arg1 = (wxImage *) 0 ;
13953 wxRect *arg2 = 0 ;
13954 byte arg3 ;
13955 byte arg4 ;
13956 byte arg5 ;
13957 void *argp1 = 0 ;
13958 int res1 = 0 ;
13959 wxRect temp2 ;
13960 unsigned char val3 ;
13961 int ecode3 = 0 ;
13962 unsigned char val4 ;
13963 int ecode4 = 0 ;
13964 unsigned char val5 ;
13965 int ecode5 = 0 ;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 PyObject * obj2 = 0 ;
13969 PyObject * obj3 = 0 ;
13970 PyObject * obj4 = 0 ;
13971 char * kwnames[] = {
13972 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13973 };
13974
13975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13977 if (!SWIG_IsOK(res1)) {
13978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13979 }
13980 arg1 = reinterpret_cast< wxImage * >(argp1);
13981 {
13982 arg2 = &temp2;
13983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13984 }
13985 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13986 if (!SWIG_IsOK(ecode3)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13988 }
13989 arg3 = static_cast< byte >(val3);
13990 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13991 if (!SWIG_IsOK(ecode4)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13993 }
13994 arg4 = static_cast< byte >(val4);
13995 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13996 if (!SWIG_IsOK(ecode5)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13998 }
13999 arg5 = static_cast< byte >(val5);
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14003 wxPyEndAllowThreads(__tstate);
14004 if (PyErr_Occurred()) SWIG_fail;
14005 }
14006 resultobj = SWIG_Py_Void();
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj = 0;
14015 wxImage *arg1 = (wxImage *) 0 ;
14016 int arg2 ;
14017 int arg3 ;
14018 byte result;
14019 void *argp1 = 0 ;
14020 int res1 = 0 ;
14021 int val2 ;
14022 int ecode2 = 0 ;
14023 int val3 ;
14024 int ecode3 = 0 ;
14025 PyObject * obj0 = 0 ;
14026 PyObject * obj1 = 0 ;
14027 PyObject * obj2 = 0 ;
14028 char * kwnames[] = {
14029 (char *) "self",(char *) "x",(char *) "y", NULL
14030 };
14031
14032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14034 if (!SWIG_IsOK(res1)) {
14035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14036 }
14037 arg1 = reinterpret_cast< wxImage * >(argp1);
14038 ecode2 = SWIG_AsVal_int(obj1, &val2);
14039 if (!SWIG_IsOK(ecode2)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14041 }
14042 arg2 = static_cast< int >(val2);
14043 ecode3 = SWIG_AsVal_int(obj2, &val3);
14044 if (!SWIG_IsOK(ecode3)) {
14045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14046 }
14047 arg3 = static_cast< int >(val3);
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (byte)(arg1)->GetRed(arg2,arg3);
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxImage *arg1 = (wxImage *) 0 ;
14064 int arg2 ;
14065 int arg3 ;
14066 byte result;
14067 void *argp1 = 0 ;
14068 int res1 = 0 ;
14069 int val2 ;
14070 int ecode2 = 0 ;
14071 int val3 ;
14072 int ecode3 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 PyObject * obj2 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "x",(char *) "y", NULL
14078 };
14079
14080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14082 if (!SWIG_IsOK(res1)) {
14083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14084 }
14085 arg1 = reinterpret_cast< wxImage * >(argp1);
14086 ecode2 = SWIG_AsVal_int(obj1, &val2);
14087 if (!SWIG_IsOK(ecode2)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14089 }
14090 arg2 = static_cast< int >(val2);
14091 ecode3 = SWIG_AsVal_int(obj2, &val3);
14092 if (!SWIG_IsOK(ecode3)) {
14093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14094 }
14095 arg3 = static_cast< int >(val3);
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 result = (byte)(arg1)->GetGreen(arg2,arg3);
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14103 return resultobj;
14104 fail:
14105 return NULL;
14106 }
14107
14108
14109 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14110 PyObject *resultobj = 0;
14111 wxImage *arg1 = (wxImage *) 0 ;
14112 int arg2 ;
14113 int arg3 ;
14114 byte result;
14115 void *argp1 = 0 ;
14116 int res1 = 0 ;
14117 int val2 ;
14118 int ecode2 = 0 ;
14119 int val3 ;
14120 int ecode3 = 0 ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 PyObject * obj2 = 0 ;
14124 char * kwnames[] = {
14125 (char *) "self",(char *) "x",(char *) "y", NULL
14126 };
14127
14128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14130 if (!SWIG_IsOK(res1)) {
14131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14132 }
14133 arg1 = reinterpret_cast< wxImage * >(argp1);
14134 ecode2 = SWIG_AsVal_int(obj1, &val2);
14135 if (!SWIG_IsOK(ecode2)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14137 }
14138 arg2 = static_cast< int >(val2);
14139 ecode3 = SWIG_AsVal_int(obj2, &val3);
14140 if (!SWIG_IsOK(ecode3)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14142 }
14143 arg3 = static_cast< int >(val3);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (byte)(arg1)->GetBlue(arg2,arg3);
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxImage *arg1 = (wxImage *) 0 ;
14160 int arg2 ;
14161 int arg3 ;
14162 byte arg4 ;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 int val2 ;
14166 int ecode2 = 0 ;
14167 int val3 ;
14168 int ecode3 = 0 ;
14169 unsigned char val4 ;
14170 int ecode4 = 0 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 PyObject * obj3 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14183 }
14184 arg1 = reinterpret_cast< wxImage * >(argp1);
14185 ecode2 = SWIG_AsVal_int(obj1, &val2);
14186 if (!SWIG_IsOK(ecode2)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14188 }
14189 arg2 = static_cast< int >(val2);
14190 ecode3 = SWIG_AsVal_int(obj2, &val3);
14191 if (!SWIG_IsOK(ecode3)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14193 }
14194 arg3 = static_cast< int >(val3);
14195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14196 if (!SWIG_IsOK(ecode4)) {
14197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14198 }
14199 arg4 = static_cast< byte >(val4);
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 (arg1)->SetAlpha(arg2,arg3,arg4);
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_Py_Void();
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj = 0;
14215 wxImage *arg1 = (wxImage *) 0 ;
14216 int arg2 ;
14217 int arg3 ;
14218 byte result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 int val2 ;
14222 int ecode2 = 0 ;
14223 int val3 ;
14224 int ecode3 = 0 ;
14225 PyObject * obj0 = 0 ;
14226 PyObject * obj1 = 0 ;
14227 PyObject * obj2 = 0 ;
14228 char * kwnames[] = {
14229 (char *) "self",(char *) "x",(char *) "y", NULL
14230 };
14231
14232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14234 if (!SWIG_IsOK(res1)) {
14235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14236 }
14237 arg1 = reinterpret_cast< wxImage * >(argp1);
14238 ecode2 = SWIG_AsVal_int(obj1, &val2);
14239 if (!SWIG_IsOK(ecode2)) {
14240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14241 }
14242 arg2 = static_cast< int >(val2);
14243 ecode3 = SWIG_AsVal_int(obj2, &val3);
14244 if (!SWIG_IsOK(ecode3)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14246 }
14247 arg3 = static_cast< int >(val3);
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14262 PyObject *resultobj = 0;
14263 wxImage *arg1 = (wxImage *) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 PyObject *swig_obj[1] ;
14268
14269 if (!args) SWIG_fail;
14270 swig_obj[0] = args;
14271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14272 if (!SWIG_IsOK(res1)) {
14273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14274 }
14275 arg1 = reinterpret_cast< wxImage * >(argp1);
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (bool)(arg1)->HasAlpha();
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 {
14283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImage *arg1 = (wxImage *) 0 ;
14294 void *argp1 = 0 ;
14295 int res1 = 0 ;
14296 PyObject *swig_obj[1] ;
14297
14298 if (!args) SWIG_fail;
14299 swig_obj[0] = args;
14300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14301 if (!SWIG_IsOK(res1)) {
14302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14303 }
14304 arg1 = reinterpret_cast< wxImage * >(argp1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 (arg1)->InitAlpha();
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 resultobj = SWIG_Py_Void();
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxImage *arg1 = (wxImage *) 0 ;
14321 int arg2 ;
14322 int arg3 ;
14323 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14324 bool result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 int val2 ;
14328 int ecode2 = 0 ;
14329 int val3 ;
14330 int ecode3 = 0 ;
14331 unsigned char val4 ;
14332 int ecode4 = 0 ;
14333 PyObject * obj0 = 0 ;
14334 PyObject * obj1 = 0 ;
14335 PyObject * obj2 = 0 ;
14336 PyObject * obj3 = 0 ;
14337 char * kwnames[] = {
14338 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14339 };
14340
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14343 if (!SWIG_IsOK(res1)) {
14344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14345 }
14346 arg1 = reinterpret_cast< wxImage * >(argp1);
14347 ecode2 = SWIG_AsVal_int(obj1, &val2);
14348 if (!SWIG_IsOK(ecode2)) {
14349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14350 }
14351 arg2 = static_cast< int >(val2);
14352 ecode3 = SWIG_AsVal_int(obj2, &val3);
14353 if (!SWIG_IsOK(ecode3)) {
14354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14355 }
14356 arg3 = static_cast< int >(val3);
14357 if (obj3) {
14358 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14359 if (!SWIG_IsOK(ecode4)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14361 }
14362 arg4 = static_cast< byte >(val4);
14363 }
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 {
14371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14372 }
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj = 0;
14381 wxImage *arg1 = (wxImage *) 0 ;
14382 byte *arg2 = (byte *) 0 ;
14383 byte *arg3 = (byte *) 0 ;
14384 byte *arg4 = (byte *) 0 ;
14385 byte arg5 = (byte) 0 ;
14386 byte arg6 = (byte) 0 ;
14387 byte arg7 = (byte) 0 ;
14388 bool result;
14389 void *argp1 = 0 ;
14390 int res1 = 0 ;
14391 byte temp2 ;
14392 int res2 = SWIG_TMPOBJ ;
14393 byte temp3 ;
14394 int res3 = SWIG_TMPOBJ ;
14395 byte temp4 ;
14396 int res4 = SWIG_TMPOBJ ;
14397 unsigned char val5 ;
14398 int ecode5 = 0 ;
14399 unsigned char val6 ;
14400 int ecode6 = 0 ;
14401 unsigned char val7 ;
14402 int ecode7 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 PyObject * obj3 = 0 ;
14407 char * kwnames[] = {
14408 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14409 };
14410
14411 arg2 = &temp2;
14412 arg3 = &temp3;
14413 arg4 = &temp4;
14414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14416 if (!SWIG_IsOK(res1)) {
14417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14418 }
14419 arg1 = reinterpret_cast< wxImage * >(argp1);
14420 if (obj1) {
14421 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14422 if (!SWIG_IsOK(ecode5)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14424 }
14425 arg5 = static_cast< byte >(val5);
14426 }
14427 if (obj2) {
14428 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14429 if (!SWIG_IsOK(ecode6)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14431 }
14432 arg6 = static_cast< byte >(val6);
14433 }
14434 if (obj3) {
14435 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14436 if (!SWIG_IsOK(ecode7)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14438 }
14439 arg7 = static_cast< byte >(val7);
14440 }
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 {
14448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14449 }
14450 if (SWIG_IsTmpObj(res2)) {
14451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14452 } else {
14453 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14455 }
14456 if (SWIG_IsTmpObj(res3)) {
14457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14458 } else {
14459 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14461 }
14462 if (SWIG_IsTmpObj(res4)) {
14463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14464 } else {
14465 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = 0;
14476 wxImage *arg1 = (wxImage *) 0 ;
14477 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14478 bool result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 unsigned char val2 ;
14482 int ecode2 = 0 ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "threshold", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImage * >(argp1);
14495 if (obj1) {
14496 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14497 if (!SWIG_IsOK(ecode2)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14499 }
14500 arg2 = static_cast< byte >(val2);
14501 }
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImage *arg1 = (wxImage *) 0 ;
14520 byte arg2 ;
14521 byte arg3 ;
14522 byte arg4 ;
14523 bool result;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 unsigned char val2 ;
14527 int ecode2 = 0 ;
14528 unsigned char val3 ;
14529 int ecode3 = 0 ;
14530 unsigned char val4 ;
14531 int ecode4 = 0 ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 PyObject * obj2 = 0 ;
14535 PyObject * obj3 = 0 ;
14536 char * kwnames[] = {
14537 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14538 };
14539
14540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14544 }
14545 arg1 = reinterpret_cast< wxImage * >(argp1);
14546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14547 if (!SWIG_IsOK(ecode2)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14549 }
14550 arg2 = static_cast< byte >(val2);
14551 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14552 if (!SWIG_IsOK(ecode3)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14554 }
14555 arg3 = static_cast< byte >(val3);
14556 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14557 if (!SWIG_IsOK(ecode4)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14559 }
14560 arg4 = static_cast< byte >(val4);
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 {
14568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14569 }
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14577 PyObject *resultobj = 0;
14578 wxImage *arg1 = (wxImage *) 0 ;
14579 wxImage *arg2 = 0 ;
14580 byte arg3 ;
14581 byte arg4 ;
14582 byte arg5 ;
14583 bool result;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 void *argp2 = 0 ;
14587 int res2 = 0 ;
14588 unsigned char val3 ;
14589 int ecode3 = 0 ;
14590 unsigned char val4 ;
14591 int ecode4 = 0 ;
14592 unsigned char val5 ;
14593 int ecode5 = 0 ;
14594 PyObject * obj0 = 0 ;
14595 PyObject * obj1 = 0 ;
14596 PyObject * obj2 = 0 ;
14597 PyObject * obj3 = 0 ;
14598 PyObject * obj4 = 0 ;
14599 char * kwnames[] = {
14600 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14601 };
14602
14603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14607 }
14608 arg1 = reinterpret_cast< wxImage * >(argp1);
14609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14610 if (!SWIG_IsOK(res2)) {
14611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14612 }
14613 if (!argp2) {
14614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14615 }
14616 arg2 = reinterpret_cast< wxImage * >(argp2);
14617 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14618 if (!SWIG_IsOK(ecode3)) {
14619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14620 }
14621 arg3 = static_cast< byte >(val3);
14622 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14623 if (!SWIG_IsOK(ecode4)) {
14624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14625 }
14626 arg4 = static_cast< byte >(val4);
14627 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14628 if (!SWIG_IsOK(ecode5)) {
14629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14630 }
14631 arg5 = static_cast< byte >(val5);
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 {
14639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14640 }
14641 return resultobj;
14642 fail:
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14648 PyObject *resultobj = 0;
14649 wxString *arg1 = 0 ;
14650 bool result;
14651 bool temp1 = false ;
14652 PyObject * obj0 = 0 ;
14653 char * kwnames[] = {
14654 (char *) "filename", NULL
14655 };
14656
14657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14658 {
14659 arg1 = wxString_in_helper(obj0);
14660 if (arg1 == NULL) SWIG_fail;
14661 temp1 = true;
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 {
14670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14671 }
14672 {
14673 if (temp1)
14674 delete arg1;
14675 }
14676 return resultobj;
14677 fail:
14678 {
14679 if (temp1)
14680 delete arg1;
14681 }
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj = 0;
14688 wxString *arg1 = 0 ;
14689 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14690 int result;
14691 bool temp1 = false ;
14692 long val2 ;
14693 int ecode2 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "filename",(char *) "type", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14701 {
14702 arg1 = wxString_in_helper(obj0);
14703 if (arg1 == NULL) SWIG_fail;
14704 temp1 = true;
14705 }
14706 if (obj1) {
14707 ecode2 = SWIG_AsVal_long(obj1, &val2);
14708 if (!SWIG_IsOK(ecode2)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14710 }
14711 arg2 = static_cast< long >(val2);
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 resultobj = SWIG_From_int(static_cast< int >(result));
14720 {
14721 if (temp1)
14722 delete arg1;
14723 }
14724 return resultobj;
14725 fail:
14726 {
14727 if (temp1)
14728 delete arg1;
14729 }
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj = 0;
14736 wxImage *arg1 = (wxImage *) 0 ;
14737 wxString *arg2 = 0 ;
14738 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14739 int arg4 = (int) -1 ;
14740 bool result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 bool temp2 = false ;
14744 long val3 ;
14745 int ecode3 = 0 ;
14746 int val4 ;
14747 int ecode4 = 0 ;
14748 PyObject * obj0 = 0 ;
14749 PyObject * obj1 = 0 ;
14750 PyObject * obj2 = 0 ;
14751 PyObject * obj3 = 0 ;
14752 char * kwnames[] = {
14753 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14754 };
14755
14756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14760 }
14761 arg1 = reinterpret_cast< wxImage * >(argp1);
14762 {
14763 arg2 = wxString_in_helper(obj1);
14764 if (arg2 == NULL) SWIG_fail;
14765 temp2 = true;
14766 }
14767 if (obj2) {
14768 ecode3 = SWIG_AsVal_long(obj2, &val3);
14769 if (!SWIG_IsOK(ecode3)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14771 }
14772 arg3 = static_cast< long >(val3);
14773 }
14774 if (obj3) {
14775 ecode4 = SWIG_AsVal_int(obj3, &val4);
14776 if (!SWIG_IsOK(ecode4)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14778 }
14779 arg4 = static_cast< int >(val4);
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 {
14791 if (temp2)
14792 delete arg2;
14793 }
14794 return resultobj;
14795 fail:
14796 {
14797 if (temp2)
14798 delete arg2;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = 0;
14806 wxImage *arg1 = (wxImage *) 0 ;
14807 wxString *arg2 = 0 ;
14808 wxString *arg3 = 0 ;
14809 int arg4 = (int) -1 ;
14810 bool result;
14811 void *argp1 = 0 ;
14812 int res1 = 0 ;
14813 bool temp2 = false ;
14814 bool temp3 = false ;
14815 int val4 ;
14816 int ecode4 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 PyObject * obj3 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14829 }
14830 arg1 = reinterpret_cast< wxImage * >(argp1);
14831 {
14832 arg2 = wxString_in_helper(obj1);
14833 if (arg2 == NULL) SWIG_fail;
14834 temp2 = true;
14835 }
14836 {
14837 arg3 = wxString_in_helper(obj2);
14838 if (arg3 == NULL) SWIG_fail;
14839 temp3 = true;
14840 }
14841 if (obj3) {
14842 ecode4 = SWIG_AsVal_int(obj3, &val4);
14843 if (!SWIG_IsOK(ecode4)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14845 }
14846 arg4 = static_cast< int >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 {
14858 if (temp2)
14859 delete arg2;
14860 }
14861 {
14862 if (temp3)
14863 delete arg3;
14864 }
14865 return resultobj;
14866 fail:
14867 {
14868 if (temp2)
14869 delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 wxString *arg2 = 0 ;
14883 int arg3 ;
14884 bool result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 bool temp2 = false ;
14888 int val3 ;
14889 int ecode3 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "self",(char *) "name",(char *) "type", NULL
14895 };
14896
14897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14899 if (!SWIG_IsOK(res1)) {
14900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14901 }
14902 arg1 = reinterpret_cast< wxImage * >(argp1);
14903 {
14904 arg2 = wxString_in_helper(obj1);
14905 if (arg2 == NULL) SWIG_fail;
14906 temp2 = true;
14907 }
14908 ecode3 = SWIG_AsVal_int(obj2, &val3);
14909 if (!SWIG_IsOK(ecode3)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14911 }
14912 arg3 = static_cast< int >(val3);
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 {
14920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj = 0;
14938 wxImage *arg1 = (wxImage *) 0 ;
14939 wxString *arg2 = 0 ;
14940 wxString *arg3 = 0 ;
14941 bool result;
14942 void *argp1 = 0 ;
14943 int res1 = 0 ;
14944 bool temp2 = false ;
14945 bool temp3 = false ;
14946 PyObject * obj0 = 0 ;
14947 PyObject * obj1 = 0 ;
14948 PyObject * obj2 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14957 }
14958 arg1 = reinterpret_cast< wxImage * >(argp1);
14959 {
14960 arg2 = wxString_in_helper(obj1);
14961 if (arg2 == NULL) SWIG_fail;
14962 temp2 = true;
14963 }
14964 {
14965 arg3 = wxString_in_helper(obj2);
14966 if (arg3 == NULL) SWIG_fail;
14967 temp3 = true;
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 {
14979 if (temp2)
14980 delete arg2;
14981 }
14982 {
14983 if (temp3)
14984 delete arg3;
14985 }
14986 return resultobj;
14987 fail:
14988 {
14989 if (temp2)
14990 delete arg2;
14991 }
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj = 0;
15002 wxInputStream *arg1 = 0 ;
15003 bool result;
15004 wxPyInputStream *temp1 ;
15005 bool created1 ;
15006 PyObject * obj0 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "stream", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15012 {
15013 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15014 arg1 = temp1->m_wxis;
15015 created1 = false;
15016 } else {
15017 PyErr_Clear(); // clear the failure of the wxPyConvert above
15018 arg1 = wxPyCBInputStream_create(obj0, false);
15019 if (arg1 == NULL) {
15020 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15021 SWIG_fail;
15022 }
15023 created1 = true;
15024 }
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 result = (bool)wxImage::CanRead(*arg1);
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 {
15033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15034 }
15035 {
15036 if (created1) delete arg1;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (created1) delete arg1;
15042 }
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 wxInputStream *arg2 = 0 ;
15051 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15052 int arg4 = (int) -1 ;
15053 bool result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 wxPyInputStream *temp2 ;
15057 bool created2 ;
15058 long val3 ;
15059 int ecode3 = 0 ;
15060 int val4 ;
15061 int ecode4 = 0 ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 PyObject * obj2 = 0 ;
15065 PyObject * obj3 = 0 ;
15066 char * kwnames[] = {
15067 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15068 };
15069
15070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15072 if (!SWIG_IsOK(res1)) {
15073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15074 }
15075 arg1 = reinterpret_cast< wxImage * >(argp1);
15076 {
15077 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15078 arg2 = temp2->m_wxis;
15079 created2 = false;
15080 } else {
15081 PyErr_Clear(); // clear the failure of the wxPyConvert above
15082 arg2 = wxPyCBInputStream_create(obj1, false);
15083 if (arg2 == NULL) {
15084 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15085 SWIG_fail;
15086 }
15087 created2 = true;
15088 }
15089 }
15090 if (obj2) {
15091 ecode3 = SWIG_AsVal_long(obj2, &val3);
15092 if (!SWIG_IsOK(ecode3)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15094 }
15095 arg3 = static_cast< long >(val3);
15096 }
15097 if (obj3) {
15098 ecode4 = SWIG_AsVal_int(obj3, &val4);
15099 if (!SWIG_IsOK(ecode4)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15101 }
15102 arg4 = static_cast< int >(val4);
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 {
15114 if (created2) delete arg2;
15115 }
15116 return resultobj;
15117 fail:
15118 {
15119 if (created2) delete arg2;
15120 }
15121 return NULL;
15122 }
15123
15124
15125 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj = 0;
15127 wxImage *arg1 = (wxImage *) 0 ;
15128 wxInputStream *arg2 = 0 ;
15129 wxString *arg3 = 0 ;
15130 int arg4 = (int) -1 ;
15131 bool result;
15132 void *argp1 = 0 ;
15133 int res1 = 0 ;
15134 wxPyInputStream *temp2 ;
15135 bool created2 ;
15136 bool temp3 = false ;
15137 int val4 ;
15138 int ecode4 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 PyObject * obj3 = 0 ;
15143 char * kwnames[] = {
15144 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15145 };
15146
15147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15149 if (!SWIG_IsOK(res1)) {
15150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15151 }
15152 arg1 = reinterpret_cast< wxImage * >(argp1);
15153 {
15154 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15155 arg2 = temp2->m_wxis;
15156 created2 = false;
15157 } else {
15158 PyErr_Clear(); // clear the failure of the wxPyConvert above
15159 arg2 = wxPyCBInputStream_create(obj1, false);
15160 if (arg2 == NULL) {
15161 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15162 SWIG_fail;
15163 }
15164 created2 = true;
15165 }
15166 }
15167 {
15168 arg3 = wxString_in_helper(obj2);
15169 if (arg3 == NULL) SWIG_fail;
15170 temp3 = true;
15171 }
15172 if (obj3) {
15173 ecode4 = SWIG_AsVal_int(obj3, &val4);
15174 if (!SWIG_IsOK(ecode4)) {
15175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15176 }
15177 arg4 = static_cast< int >(val4);
15178 }
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 {
15189 if (created2) delete arg2;
15190 }
15191 {
15192 if (temp3)
15193 delete arg3;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (created2) delete arg2;
15199 }
15200 {
15201 if (temp3)
15202 delete arg3;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 PyObject *resultobj = 0;
15210 wxImage *arg1 = (wxImage *) 0 ;
15211 bool result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 PyObject *swig_obj[1] ;
15215
15216 if (!args) SWIG_fail;
15217 swig_obj[0] = args;
15218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage * >(argp1);
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (bool)(arg1)->Ok();
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 {
15230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15231 }
15232 return resultobj;
15233 fail:
15234 return NULL;
15235 }
15236
15237
15238 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15239 PyObject *resultobj = 0;
15240 wxImage *arg1 = (wxImage *) 0 ;
15241 int result;
15242 void *argp1 = 0 ;
15243 int res1 = 0 ;
15244 PyObject *swig_obj[1] ;
15245
15246 if (!args) SWIG_fail;
15247 swig_obj[0] = args;
15248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15251 }
15252 arg1 = reinterpret_cast< wxImage * >(argp1);
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (int)(arg1)->GetWidth();
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 resultobj = SWIG_From_int(static_cast< int >(result));
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15267 PyObject *resultobj = 0;
15268 wxImage *arg1 = (wxImage *) 0 ;
15269 int result;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 PyObject *swig_obj[1] ;
15273
15274 if (!args) SWIG_fail;
15275 swig_obj[0] = args;
15276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15279 }
15280 arg1 = reinterpret_cast< wxImage * >(argp1);
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (int)(arg1)->GetHeight();
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 resultobj = SWIG_From_int(static_cast< int >(result));
15288 return resultobj;
15289 fail:
15290 return NULL;
15291 }
15292
15293
15294 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15295 PyObject *resultobj = 0;
15296 wxImage *arg1 = (wxImage *) 0 ;
15297 wxSize result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 PyObject *swig_obj[1] ;
15301
15302 if (!args) SWIG_fail;
15303 swig_obj[0] = args;
15304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15305 if (!SWIG_IsOK(res1)) {
15306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15307 }
15308 arg1 = reinterpret_cast< wxImage * >(argp1);
15309 {
15310 PyThreadState* __tstate = wxPyBeginAllowThreads();
15311 result = wxImage_GetSize(arg1);
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj = 0;
15324 wxImage *arg1 = (wxImage *) 0 ;
15325 wxRect *arg2 = 0 ;
15326 SwigValueWrapper<wxImage > result;
15327 void *argp1 = 0 ;
15328 int res1 = 0 ;
15329 wxRect temp2 ;
15330 PyObject * obj0 = 0 ;
15331 PyObject * obj1 = 0 ;
15332 char * kwnames[] = {
15333 (char *) "self",(char *) "rect", NULL
15334 };
15335
15336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15340 }
15341 arg1 = reinterpret_cast< wxImage * >(argp1);
15342 {
15343 arg2 = &temp2;
15344 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15345 }
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj = 0;
15361 wxImage *arg1 = (wxImage *) 0 ;
15362 wxSize *arg2 = 0 ;
15363 wxPoint *arg3 = 0 ;
15364 int arg4 = (int) -1 ;
15365 int arg5 = (int) -1 ;
15366 int arg6 = (int) -1 ;
15367 SwigValueWrapper<wxImage > result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 wxSize temp2 ;
15371 wxPoint temp3 ;
15372 int val4 ;
15373 int ecode4 = 0 ;
15374 int val5 ;
15375 int ecode5 = 0 ;
15376 int val6 ;
15377 int ecode6 = 0 ;
15378 PyObject * obj0 = 0 ;
15379 PyObject * obj1 = 0 ;
15380 PyObject * obj2 = 0 ;
15381 PyObject * obj3 = 0 ;
15382 PyObject * obj4 = 0 ;
15383 PyObject * obj5 = 0 ;
15384 char * kwnames[] = {
15385 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15386 };
15387
15388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 arg2 = &temp2;
15396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15397 }
15398 {
15399 arg3 = &temp3;
15400 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15401 }
15402 if (obj3) {
15403 ecode4 = SWIG_AsVal_int(obj3, &val4);
15404 if (!SWIG_IsOK(ecode4)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15406 }
15407 arg4 = static_cast< int >(val4);
15408 }
15409 if (obj4) {
15410 ecode5 = SWIG_AsVal_int(obj4, &val5);
15411 if (!SWIG_IsOK(ecode5)) {
15412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15413 }
15414 arg5 = static_cast< int >(val5);
15415 }
15416 if (obj5) {
15417 ecode6 = SWIG_AsVal_int(obj5, &val6);
15418 if (!SWIG_IsOK(ecode6)) {
15419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15420 }
15421 arg6 = static_cast< int >(val6);
15422 }
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage *arg1 = (wxImage *) 0 ;
15439 SwigValueWrapper<wxImage > result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage * >(argp1);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (arg1)->Copy();
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj = 0;
15466 wxImage *arg1 = (wxImage *) 0 ;
15467 wxImage *arg2 = 0 ;
15468 int arg3 ;
15469 int arg4 ;
15470 void *argp1 = 0 ;
15471 int res1 = 0 ;
15472 void *argp2 = 0 ;
15473 int res2 = 0 ;
15474 int val3 ;
15475 int ecode3 = 0 ;
15476 int val4 ;
15477 int ecode4 = 0 ;
15478 PyObject * obj0 = 0 ;
15479 PyObject * obj1 = 0 ;
15480 PyObject * obj2 = 0 ;
15481 PyObject * obj3 = 0 ;
15482 char * kwnames[] = {
15483 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15484 };
15485
15486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15493 if (!SWIG_IsOK(res2)) {
15494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15495 }
15496 if (!argp2) {
15497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15498 }
15499 arg2 = reinterpret_cast< wxImage * >(argp2);
15500 ecode3 = SWIG_AsVal_int(obj2, &val3);
15501 if (!SWIG_IsOK(ecode3)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15503 }
15504 arg3 = static_cast< int >(val3);
15505 ecode4 = SWIG_AsVal_int(obj3, &val4);
15506 if (!SWIG_IsOK(ecode4)) {
15507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15508 }
15509 arg4 = static_cast< int >(val4);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage *arg1 = (wxImage *) 0 ;
15526 PyObject *result = 0 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (PyObject *)wxImage_GetData(arg1);
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = result;
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxImage *arg1 = (wxImage *) 0 ;
15554 buffer arg2 ;
15555 int arg3 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 Py_ssize_t temp2 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "data", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15569 }
15570 arg1 = reinterpret_cast< wxImage * >(argp1);
15571 {
15572 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15573 arg3 = (int)temp2;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 Py_ssize_t temp2 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "data", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15634 }
15635 arg1 = reinterpret_cast< wxImage * >(argp1);
15636 {
15637 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15638 arg3 = (int)temp2;
15639 }
15640 {
15641 PyThreadState* __tstate = wxPyBeginAllowThreads();
15642 wxImage_SetDataBuffer(arg1,arg2,arg3);
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 resultobj = SWIG_Py_Void();
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxImage *arg1 = (wxImage *) 0 ;
15656 PyObject *result = 0 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15666 }
15667 arg1 = reinterpret_cast< wxImage * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (PyObject *)wxImage_GetAlphaData(arg1);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = result;
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 buffer arg2 ;
15685 int arg3 ;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 Py_ssize_t temp2 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char * kwnames[] = {
15692 (char *) "self",(char *) "alpha", NULL
15693 };
15694
15695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15699 }
15700 arg1 = reinterpret_cast< wxImage * >(argp1);
15701 {
15702 if (obj1 != Py_None) {
15703 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15704 arg3 = (int)temp2;
15705 }
15706 }
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 wxImage_SetAlphaData(arg1,arg2,arg3);
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 resultobj = SWIG_Py_Void();
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15721 PyObject *resultobj = 0;
15722 wxImage *arg1 = (wxImage *) 0 ;
15723 PyObject *result = 0 ;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 PyObject *swig_obj[1] ;
15727
15728 if (!args) SWIG_fail;
15729 swig_obj[0] = args;
15730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15733 }
15734 arg1 = reinterpret_cast< wxImage * >(argp1);
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = result;
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = 0;
15750 wxImage *arg1 = (wxImage *) 0 ;
15751 buffer arg2 ;
15752 int arg3 ;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 Py_ssize_t temp2 ;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 char * kwnames[] = {
15759 (char *) "self",(char *) "alpha", NULL
15760 };
15761
15762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 if (obj1 != Py_None) {
15770 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15771 arg3 = (int)temp2;
15772 }
15773 }
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 resultobj = SWIG_Py_Void();
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj = 0;
15789 wxImage *arg1 = (wxImage *) 0 ;
15790 byte arg2 ;
15791 byte arg3 ;
15792 byte arg4 ;
15793 void *argp1 = 0 ;
15794 int res1 = 0 ;
15795 unsigned char val2 ;
15796 int ecode2 = 0 ;
15797 unsigned char val3 ;
15798 int ecode3 = 0 ;
15799 unsigned char val4 ;
15800 int ecode4 = 0 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 PyObject * obj2 = 0 ;
15804 PyObject * obj3 = 0 ;
15805 char * kwnames[] = {
15806 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15807 };
15808
15809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15813 }
15814 arg1 = reinterpret_cast< wxImage * >(argp1);
15815 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15816 if (!SWIG_IsOK(ecode2)) {
15817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15818 }
15819 arg2 = static_cast< byte >(val2);
15820 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15821 if (!SWIG_IsOK(ecode3)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15823 }
15824 arg3 = static_cast< byte >(val3);
15825 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15826 if (!SWIG_IsOK(ecode4)) {
15827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15828 }
15829 arg4 = static_cast< byte >(val4);
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 (arg1)->SetMaskColour(arg2,arg3,arg4);
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 resultobj = SWIG_Py_Void();
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *resultobj = 0;
15845 wxImage *arg1 = (wxImage *) 0 ;
15846 byte *arg2 = (byte *) 0 ;
15847 byte *arg3 = (byte *) 0 ;
15848 byte *arg4 = (byte *) 0 ;
15849 void *argp1 = 0 ;
15850 int res1 = 0 ;
15851 byte temp2 ;
15852 int res2 = SWIG_TMPOBJ ;
15853 byte temp3 ;
15854 int res3 = SWIG_TMPOBJ ;
15855 byte temp4 ;
15856 int res4 = SWIG_TMPOBJ ;
15857 PyObject *swig_obj[1] ;
15858
15859 arg2 = &temp2;
15860 arg3 = &temp3;
15861 arg4 = &temp4;
15862 if (!args) SWIG_fail;
15863 swig_obj[0] = args;
15864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 resultobj = SWIG_Py_Void();
15876 if (SWIG_IsTmpObj(res2)) {
15877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15878 } else {
15879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15881 }
15882 if (SWIG_IsTmpObj(res3)) {
15883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15884 } else {
15885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15887 }
15888 if (SWIG_IsTmpObj(res4)) {
15889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15890 } else {
15891 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15901 PyObject *resultobj = 0;
15902 wxImage *arg1 = (wxImage *) 0 ;
15903 byte result;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject *swig_obj[1] ;
15907
15908 if (!args) SWIG_fail;
15909 swig_obj[0] = args;
15910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15911 if (!SWIG_IsOK(res1)) {
15912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15913 }
15914 arg1 = reinterpret_cast< wxImage * >(argp1);
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = (byte)(arg1)->GetMaskRed();
15918 wxPyEndAllowThreads(__tstate);
15919 if (PyErr_Occurred()) SWIG_fail;
15920 }
15921 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15922 return resultobj;
15923 fail:
15924 return NULL;
15925 }
15926
15927
15928 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15929 PyObject *resultobj = 0;
15930 wxImage *arg1 = (wxImage *) 0 ;
15931 byte result;
15932 void *argp1 = 0 ;
15933 int res1 = 0 ;
15934 PyObject *swig_obj[1] ;
15935
15936 if (!args) SWIG_fail;
15937 swig_obj[0] = args;
15938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15939 if (!SWIG_IsOK(res1)) {
15940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15941 }
15942 arg1 = reinterpret_cast< wxImage * >(argp1);
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (byte)(arg1)->GetMaskGreen();
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15957 PyObject *resultobj = 0;
15958 wxImage *arg1 = (wxImage *) 0 ;
15959 byte result;
15960 void *argp1 = 0 ;
15961 int res1 = 0 ;
15962 PyObject *swig_obj[1] ;
15963
15964 if (!args) SWIG_fail;
15965 swig_obj[0] = args;
15966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15967 if (!SWIG_IsOK(res1)) {
15968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15969 }
15970 arg1 = reinterpret_cast< wxImage * >(argp1);
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 result = (byte)(arg1)->GetMaskBlue();
15974 wxPyEndAllowThreads(__tstate);
15975 if (PyErr_Occurred()) SWIG_fail;
15976 }
15977 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15978 return resultobj;
15979 fail:
15980 return NULL;
15981 }
15982
15983
15984 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15985 PyObject *resultobj = 0;
15986 wxImage *arg1 = (wxImage *) 0 ;
15987 bool arg2 = (bool) true ;
15988 void *argp1 = 0 ;
15989 int res1 = 0 ;
15990 bool val2 ;
15991 int ecode2 = 0 ;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 char * kwnames[] = {
15995 (char *) "self",(char *) "mask", NULL
15996 };
15997
15998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16002 }
16003 arg1 = reinterpret_cast< wxImage * >(argp1);
16004 if (obj1) {
16005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16006 if (!SWIG_IsOK(ecode2)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16008 }
16009 arg2 = static_cast< bool >(val2);
16010 }
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->SetMask(arg2);
16014 wxPyEndAllowThreads(__tstate);
16015 if (PyErr_Occurred()) SWIG_fail;
16016 }
16017 resultobj = SWIG_Py_Void();
16018 return resultobj;
16019 fail:
16020 return NULL;
16021 }
16022
16023
16024 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16025 PyObject *resultobj = 0;
16026 wxImage *arg1 = (wxImage *) 0 ;
16027 bool result;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 result = (bool)(arg1)->HasMask();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 {
16046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16047 }
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj = 0;
16056 wxImage *arg1 = (wxImage *) 0 ;
16057 double arg2 ;
16058 wxPoint *arg3 = 0 ;
16059 bool arg4 = (bool) true ;
16060 wxPoint *arg5 = (wxPoint *) NULL ;
16061 SwigValueWrapper<wxImage > result;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 double val2 ;
16065 int ecode2 = 0 ;
16066 wxPoint temp3 ;
16067 bool val4 ;
16068 int ecode4 = 0 ;
16069 void *argp5 = 0 ;
16070 int res5 = 0 ;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 PyObject * obj4 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16082 if (!SWIG_IsOK(res1)) {
16083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 ecode2 = SWIG_AsVal_double(obj1, &val2);
16087 if (!SWIG_IsOK(ecode2)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16089 }
16090 arg2 = static_cast< double >(val2);
16091 {
16092 arg3 = &temp3;
16093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16094 }
16095 if (obj3) {
16096 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16097 if (!SWIG_IsOK(ecode4)) {
16098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16099 }
16100 arg4 = static_cast< bool >(val4);
16101 }
16102 if (obj4) {
16103 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16104 if (!SWIG_IsOK(res5)) {
16105 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16106 }
16107 arg5 = reinterpret_cast< wxPoint * >(argp5);
16108 }
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = 0;
16124 wxImage *arg1 = (wxImage *) 0 ;
16125 bool arg2 = (bool) true ;
16126 SwigValueWrapper<wxImage > result;
16127 void *argp1 = 0 ;
16128 int res1 = 0 ;
16129 bool val2 ;
16130 int ecode2 = 0 ;
16131 PyObject * obj0 = 0 ;
16132 PyObject * obj1 = 0 ;
16133 char * kwnames[] = {
16134 (char *) "self",(char *) "clockwise", NULL
16135 };
16136
16137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16139 if (!SWIG_IsOK(res1)) {
16140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16141 }
16142 arg1 = reinterpret_cast< wxImage * >(argp1);
16143 if (obj1) {
16144 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16145 if (!SWIG_IsOK(ecode2)) {
16146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16147 }
16148 arg2 = static_cast< bool >(val2);
16149 }
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = (arg1)->Rotate90(arg2);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj = 0;
16165 wxImage *arg1 = (wxImage *) 0 ;
16166 bool arg2 = (bool) true ;
16167 SwigValueWrapper<wxImage > result;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 bool val2 ;
16171 int ecode2 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "horizontally", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 if (obj1) {
16185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16188 }
16189 arg2 = static_cast< bool >(val2);
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (arg1)->Mirror(arg2);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 byte arg2 ;
16208 byte arg3 ;
16209 byte arg4 ;
16210 byte arg5 ;
16211 byte arg6 ;
16212 byte arg7 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 unsigned char val2 ;
16216 int ecode2 = 0 ;
16217 unsigned char val3 ;
16218 int ecode3 = 0 ;
16219 unsigned char val4 ;
16220 int ecode4 = 0 ;
16221 unsigned char val5 ;
16222 int ecode5 = 0 ;
16223 unsigned char val6 ;
16224 int ecode6 = 0 ;
16225 unsigned char val7 ;
16226 int ecode7 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 PyObject * obj3 = 0 ;
16231 PyObject * obj4 = 0 ;
16232 PyObject * obj5 = 0 ;
16233 PyObject * obj6 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16245 if (!SWIG_IsOK(ecode2)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16247 }
16248 arg2 = static_cast< byte >(val2);
16249 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16252 }
16253 arg3 = static_cast< byte >(val3);
16254 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16255 if (!SWIG_IsOK(ecode4)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16257 }
16258 arg4 = static_cast< byte >(val4);
16259 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16260 if (!SWIG_IsOK(ecode5)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16262 }
16263 arg5 = static_cast< byte >(val5);
16264 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16265 if (!SWIG_IsOK(ecode6)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16267 }
16268 arg6 = static_cast< byte >(val6);
16269 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16270 if (!SWIG_IsOK(ecode7)) {
16271 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16272 }
16273 arg7 = static_cast< byte >(val7);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_Py_Void();
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxImage *arg1 = (wxImage *) 0 ;
16290 double arg2 = (double) 0.299 ;
16291 double arg3 = (double) 0.587 ;
16292 double arg4 = (double) 0.114 ;
16293 SwigValueWrapper<wxImage > result;
16294 void *argp1 = 0 ;
16295 int res1 = 0 ;
16296 double val2 ;
16297 int ecode2 = 0 ;
16298 double val3 ;
16299 int ecode3 = 0 ;
16300 double val4 ;
16301 int ecode4 = 0 ;
16302 PyObject * obj0 = 0 ;
16303 PyObject * obj1 = 0 ;
16304 PyObject * obj2 = 0 ;
16305 PyObject * obj3 = 0 ;
16306 char * kwnames[] = {
16307 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16308 };
16309
16310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16314 }
16315 arg1 = reinterpret_cast< wxImage * >(argp1);
16316 if (obj1) {
16317 ecode2 = SWIG_AsVal_double(obj1, &val2);
16318 if (!SWIG_IsOK(ecode2)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16320 }
16321 arg2 = static_cast< double >(val2);
16322 }
16323 if (obj2) {
16324 ecode3 = SWIG_AsVal_double(obj2, &val3);
16325 if (!SWIG_IsOK(ecode3)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16327 }
16328 arg3 = static_cast< double >(val3);
16329 }
16330 if (obj3) {
16331 ecode4 = SWIG_AsVal_double(obj3, &val4);
16332 if (!SWIG_IsOK(ecode4)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16334 }
16335 arg4 = static_cast< double >(val4);
16336 }
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16351 PyObject *resultobj = 0;
16352 wxImage *arg1 = (wxImage *) 0 ;
16353 byte arg2 ;
16354 byte arg3 ;
16355 byte arg4 ;
16356 SwigValueWrapper<wxImage > result;
16357 void *argp1 = 0 ;
16358 int res1 = 0 ;
16359 unsigned char val2 ;
16360 int ecode2 = 0 ;
16361 unsigned char val3 ;
16362 int ecode3 = 0 ;
16363 unsigned char val4 ;
16364 int ecode4 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 PyObject * obj2 = 0 ;
16368 PyObject * obj3 = 0 ;
16369 char * kwnames[] = {
16370 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16371 };
16372
16373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16375 if (!SWIG_IsOK(res1)) {
16376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16377 }
16378 arg1 = reinterpret_cast< wxImage * >(argp1);
16379 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16380 if (!SWIG_IsOK(ecode2)) {
16381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16382 }
16383 arg2 = static_cast< byte >(val2);
16384 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16385 if (!SWIG_IsOK(ecode3)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16387 }
16388 arg3 = static_cast< byte >(val3);
16389 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16390 if (!SWIG_IsOK(ecode4)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16392 }
16393 arg4 = static_cast< byte >(val4);
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj = 0;
16409 wxImage *arg1 = (wxImage *) 0 ;
16410 wxString *arg2 = 0 ;
16411 wxString *arg3 = 0 ;
16412 void *argp1 = 0 ;
16413 int res1 = 0 ;
16414 bool temp2 = false ;
16415 bool temp3 = false ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 PyObject * obj2 = 0 ;
16419 char * kwnames[] = {
16420 (char *) "self",(char *) "name",(char *) "value", NULL
16421 };
16422
16423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16427 }
16428 arg1 = reinterpret_cast< wxImage * >(argp1);
16429 {
16430 arg2 = wxString_in_helper(obj1);
16431 if (arg2 == NULL) SWIG_fail;
16432 temp2 = true;
16433 }
16434 {
16435 arg3 = wxString_in_helper(obj2);
16436 if (arg3 == NULL) SWIG_fail;
16437 temp3 = true;
16438 }
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_Py_Void();
16446 {
16447 if (temp2)
16448 delete arg2;
16449 }
16450 {
16451 if (temp3)
16452 delete arg3;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 {
16461 if (temp3)
16462 delete arg3;
16463 }
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxImage *arg1 = (wxImage *) 0 ;
16471 wxString *arg2 = 0 ;
16472 int arg3 ;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 bool temp2 = false ;
16476 int val3 ;
16477 int ecode3 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 PyObject * obj2 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "name",(char *) "value", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 {
16492 arg2 = wxString_in_helper(obj1);
16493 if (arg2 == NULL) SWIG_fail;
16494 temp2 = true;
16495 }
16496 ecode3 = SWIG_AsVal_int(obj2, &val3);
16497 if (!SWIG_IsOK(ecode3)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16499 }
16500 arg3 = static_cast< int >(val3);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 (arg1)->SetOption((wxString const &)*arg2,arg3);
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_Py_Void();
16508 {
16509 if (temp2)
16510 delete arg2;
16511 }
16512 return resultobj;
16513 fail:
16514 {
16515 if (temp2)
16516 delete arg2;
16517 }
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16523 PyObject *resultobj = 0;
16524 wxImage *arg1 = (wxImage *) 0 ;
16525 wxString *arg2 = 0 ;
16526 wxString result;
16527 void *argp1 = 0 ;
16528 int res1 = 0 ;
16529 bool temp2 = false ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 char * kwnames[] = {
16533 (char *) "self",(char *) "name", NULL
16534 };
16535
16536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16540 }
16541 arg1 = reinterpret_cast< wxImage * >(argp1);
16542 {
16543 arg2 = wxString_in_helper(obj1);
16544 if (arg2 == NULL) SWIG_fail;
16545 temp2 = true;
16546 }
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 {
16554 #if wxUSE_UNICODE
16555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16556 #else
16557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16558 #endif
16559 }
16560 {
16561 if (temp2)
16562 delete arg2;
16563 }
16564 return resultobj;
16565 fail:
16566 {
16567 if (temp2)
16568 delete arg2;
16569 }
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 wxString *arg2 = 0 ;
16578 int result;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 bool temp2 = false ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "name", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 {
16595 arg2 = wxString_in_helper(obj1);
16596 if (arg2 == NULL) SWIG_fail;
16597 temp2 = true;
16598 }
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 resultobj = SWIG_From_int(static_cast< int >(result));
16606 {
16607 if (temp2)
16608 delete arg2;
16609 }
16610 return resultobj;
16611 fail:
16612 {
16613 if (temp2)
16614 delete arg2;
16615 }
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16621 PyObject *resultobj = 0;
16622 wxImage *arg1 = (wxImage *) 0 ;
16623 wxString *arg2 = 0 ;
16624 bool result;
16625 void *argp1 = 0 ;
16626 int res1 = 0 ;
16627 bool temp2 = false ;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char * kwnames[] = {
16631 (char *) "self",(char *) "name", NULL
16632 };
16633
16634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16638 }
16639 arg1 = reinterpret_cast< wxImage * >(argp1);
16640 {
16641 arg2 = wxString_in_helper(obj1);
16642 if (arg2 == NULL) SWIG_fail;
16643 temp2 = true;
16644 }
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16653 }
16654 {
16655 if (temp2)
16656 delete arg2;
16657 }
16658 return resultobj;
16659 fail:
16660 {
16661 if (temp2)
16662 delete arg2;
16663 }
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj = 0;
16670 wxImage *arg1 = (wxImage *) 0 ;
16671 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16672 unsigned long result;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 unsigned long val2 ;
16676 int ecode2 = 0 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "self",(char *) "stopafter", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16687 }
16688 arg1 = reinterpret_cast< wxImage * >(argp1);
16689 if (obj1) {
16690 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16691 if (!SWIG_IsOK(ecode2)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16693 }
16694 arg2 = static_cast< unsigned long >(val2);
16695 }
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (unsigned long)(arg1)->CountColours(arg2);
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj = 0;
16711 wxImage *arg1 = (wxImage *) 0 ;
16712 wxImageHistogram *arg2 = 0 ;
16713 unsigned long result;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 void *argp2 = 0 ;
16717 int res2 = 0 ;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "self",(char *) "h", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16728 }
16729 arg1 = reinterpret_cast< wxImage * >(argp1);
16730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16731 if (!SWIG_IsOK(res2)) {
16732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16733 }
16734 if (!argp2) {
16735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16736 }
16737 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = 0;
16753 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 PyObject * obj0 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "handler", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16765 }
16766 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 wxImage::AddHandler(arg1);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "handler", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16794 }
16795 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 wxImage::InsertHandler(arg1);
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 resultobj = SWIG_Py_Void();
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj = 0;
16811 wxString *arg1 = 0 ;
16812 bool result;
16813 bool temp1 = false ;
16814 PyObject * obj0 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "name", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16820 {
16821 arg1 = wxString_in_helper(obj0);
16822 if (arg1 == NULL) SWIG_fail;
16823 temp1 = true;
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 {
16835 if (temp1)
16836 delete arg1;
16837 }
16838 return resultobj;
16839 fail:
16840 {
16841 if (temp1)
16842 delete arg1;
16843 }
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16849 PyObject *resultobj = 0;
16850 PyObject *result = 0 ;
16851
16852 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (PyObject *)wxImage_GetHandlers();
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = result;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 PyObject *resultobj = 0;
16868 wxString result;
16869
16870 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = wxImage::GetImageExtWildcard();
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 #if wxUSE_UNICODE
16879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16880 #else
16881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16882 #endif
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj = 0;
16892 wxImage *arg1 = (wxImage *) 0 ;
16893 int arg2 = (int) -1 ;
16894 wxBitmap result;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 int val2 ;
16898 int ecode2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "depth", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16909 }
16910 arg1 = reinterpret_cast< wxImage * >(argp1);
16911 if (obj1) {
16912 ecode2 = SWIG_AsVal_int(obj1, &val2);
16913 if (!SWIG_IsOK(ecode2)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16915 }
16916 arg2 = static_cast< int >(val2);
16917 }
16918 {
16919 if (!wxPyCheckForApp()) SWIG_fail;
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = wxImage_ConvertToBitmap(arg1,arg2);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxImage *arg1 = (wxImage *) 0 ;
16935 byte arg2 ;
16936 byte arg3 ;
16937 byte arg4 ;
16938 wxBitmap result;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 unsigned char val2 ;
16942 int ecode2 = 0 ;
16943 unsigned char val3 ;
16944 int ecode3 = 0 ;
16945 unsigned char val4 ;
16946 int ecode4 = 0 ;
16947 PyObject * obj0 = 0 ;
16948 PyObject * obj1 = 0 ;
16949 PyObject * obj2 = 0 ;
16950 PyObject * obj3 = 0 ;
16951 char * kwnames[] = {
16952 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16953 };
16954
16955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16957 if (!SWIG_IsOK(res1)) {
16958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16959 }
16960 arg1 = reinterpret_cast< wxImage * >(argp1);
16961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16962 if (!SWIG_IsOK(ecode2)) {
16963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16964 }
16965 arg2 = static_cast< byte >(val2);
16966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16967 if (!SWIG_IsOK(ecode3)) {
16968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16969 }
16970 arg3 = static_cast< byte >(val3);
16971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16972 if (!SWIG_IsOK(ecode4)) {
16973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16974 }
16975 arg4 = static_cast< byte >(val4);
16976 {
16977 if (!wxPyCheckForApp()) SWIG_fail;
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj = 0;
16992 wxImage *arg1 = (wxImage *) 0 ;
16993 double arg2 ;
16994 void *argp1 = 0 ;
16995 int res1 = 0 ;
16996 double val2 ;
16997 int ecode2 = 0 ;
16998 PyObject * obj0 = 0 ;
16999 PyObject * obj1 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "self",(char *) "angle", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17008 }
17009 arg1 = reinterpret_cast< wxImage * >(argp1);
17010 ecode2 = SWIG_AsVal_double(obj1, &val2);
17011 if (!SWIG_IsOK(ecode2)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17013 }
17014 arg2 = static_cast< double >(val2);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->RotateHue(arg2);
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxImage_RGBValue arg1 ;
17031 wxImage_HSVValue result;
17032 void *argp1 ;
17033 int res1 = 0 ;
17034 PyObject * obj0 = 0 ;
17035 char * kwnames[] = {
17036 (char *) "rgb", NULL
17037 };
17038
17039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17040 {
17041 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17042 if (!SWIG_IsOK(res1)) {
17043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17044 }
17045 if (!argp1) {
17046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17047 } else {
17048 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17049 arg1 = *temp;
17050 if (SWIG_IsNewObj(res1)) delete temp;
17051 }
17052 }
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = wxImage::RGBtoHSV(arg1);
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj = 0;
17068 wxImage_HSVValue arg1 ;
17069 wxImage_RGBValue result;
17070 void *argp1 ;
17071 int res1 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 char * kwnames[] = {
17074 (char *) "hsv", NULL
17075 };
17076
17077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17078 {
17079 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17080 if (!SWIG_IsOK(res1)) {
17081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17082 }
17083 if (!argp1) {
17084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17085 } else {
17086 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17087 arg1 = *temp;
17088 if (SWIG_IsNewObj(res1)) delete temp;
17089 }
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = wxImage::HSVtoRGB(arg1);
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17105 PyObject *obj;
17106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17107 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17108 return SWIG_Py_Void();
17109 }
17110
17111 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17112 return SWIG_Python_InitShadowInstance(args);
17113 }
17114
17115 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17116 PyObject *resultobj = 0;
17117 int arg1 ;
17118 int arg2 ;
17119 buffer arg3 ;
17120 int arg4 ;
17121 buffer arg5 = (buffer) NULL ;
17122 int arg6 = (int) 0 ;
17123 wxImage *result = 0 ;
17124 int val1 ;
17125 int ecode1 = 0 ;
17126 int val2 ;
17127 int ecode2 = 0 ;
17128 Py_ssize_t temp3 ;
17129 Py_ssize_t temp5 ;
17130 PyObject * obj0 = 0 ;
17131 PyObject * obj1 = 0 ;
17132 PyObject * obj2 = 0 ;
17133 PyObject * obj3 = 0 ;
17134 char * kwnames[] = {
17135 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17136 };
17137
17138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17139 ecode1 = SWIG_AsVal_int(obj0, &val1);
17140 if (!SWIG_IsOK(ecode1)) {
17141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17142 }
17143 arg1 = static_cast< int >(val1);
17144 ecode2 = SWIG_AsVal_int(obj1, &val2);
17145 if (!SWIG_IsOK(ecode2)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17147 }
17148 arg2 = static_cast< int >(val2);
17149 {
17150 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17151 arg4 = (int)temp3;
17152 }
17153 if (obj3) {
17154 {
17155 if (obj3 != Py_None) {
17156 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17157 arg6 = (int)temp5;
17158 }
17159 }
17160 }
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 {
17168 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17169 }
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN int NullImage_set(PyObject *) {
17177 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17178 return 1;
17179 }
17180
17181
17182 SWIGINTERN PyObject *NullImage_get(void) {
17183 PyObject *pyobj = 0;
17184
17185 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17186 return pyobj;
17187 }
17188
17189
17190 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17191 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17192 return 1;
17193 }
17194
17195
17196 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17197 PyObject *pyobj = 0;
17198
17199 {
17200 #if wxUSE_UNICODE
17201 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17202 #else
17203 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17204 #endif
17205 }
17206 return pyobj;
17207 }
17208
17209
17210 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17211 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17212 return 1;
17213 }
17214
17215
17216 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17217 PyObject *pyobj = 0;
17218
17219 {
17220 #if wxUSE_UNICODE
17221 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17222 #else
17223 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17224 #endif
17225 }
17226 return pyobj;
17227 }
17228
17229
17230 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17231 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17232 return 1;
17233 }
17234
17235
17236 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17237 PyObject *pyobj = 0;
17238
17239 {
17240 #if wxUSE_UNICODE
17241 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17242 #else
17243 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17244 #endif
17245 }
17246 return pyobj;
17247 }
17248
17249
17250 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17251 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17252 return 1;
17253 }
17254
17255
17256 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17257 PyObject *pyobj = 0;
17258
17259 {
17260 #if wxUSE_UNICODE
17261 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17262 #else
17263 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17264 #endif
17265 }
17266 return pyobj;
17267 }
17268
17269
17270 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17271 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17272 return 1;
17273 }
17274
17275
17276 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17277 PyObject *pyobj = 0;
17278
17279 {
17280 #if wxUSE_UNICODE
17281 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17282 #else
17283 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17284 #endif
17285 }
17286 return pyobj;
17287 }
17288
17289
17290 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17291 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17292 return 1;
17293 }
17294
17295
17296 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17297 PyObject *pyobj = 0;
17298
17299 {
17300 #if wxUSE_UNICODE
17301 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17302 #else
17303 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17304 #endif
17305 }
17306 return pyobj;
17307 }
17308
17309
17310 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17311 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17312 return 1;
17313 }
17314
17315
17316 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17317 PyObject *pyobj = 0;
17318
17319 {
17320 #if wxUSE_UNICODE
17321 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17322 #else
17323 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17324 #endif
17325 }
17326 return pyobj;
17327 }
17328
17329
17330 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17331 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17332 return 1;
17333 }
17334
17335
17336 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17337 PyObject *pyobj = 0;
17338
17339 {
17340 #if wxUSE_UNICODE
17341 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17342 #else
17343 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17344 #endif
17345 }
17346 return pyobj;
17347 }
17348
17349
17350 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17351 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17352 return 1;
17353 }
17354
17355
17356 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17357 PyObject *pyobj = 0;
17358
17359 {
17360 #if wxUSE_UNICODE
17361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17362 #else
17363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17364 #endif
17365 }
17366 return pyobj;
17367 }
17368
17369
17370 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17371 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17372 return 1;
17373 }
17374
17375
17376 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17377 PyObject *pyobj = 0;
17378
17379 {
17380 #if wxUSE_UNICODE
17381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17382 #else
17383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17384 #endif
17385 }
17386 return pyobj;
17387 }
17388
17389
17390 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17391 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17392 return 1;
17393 }
17394
17395
17396 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17397 PyObject *pyobj = 0;
17398
17399 {
17400 #if wxUSE_UNICODE
17401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17402 #else
17403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17404 #endif
17405 }
17406 return pyobj;
17407 }
17408
17409
17410 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17411 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17412 return 1;
17413 }
17414
17415
17416 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17417 PyObject *pyobj = 0;
17418
17419 {
17420 #if wxUSE_UNICODE
17421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17422 #else
17423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17424 #endif
17425 }
17426 return pyobj;
17427 }
17428
17429
17430 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17431 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17432 return 1;
17433 }
17434
17435
17436 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17437 PyObject *pyobj = 0;
17438
17439 {
17440 #if wxUSE_UNICODE
17441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17442 #else
17443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17444 #endif
17445 }
17446 return pyobj;
17447 }
17448
17449
17450 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17451 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17452 return 1;
17453 }
17454
17455
17456 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17457 PyObject *pyobj = 0;
17458
17459 {
17460 #if wxUSE_UNICODE
17461 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17462 #else
17463 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17464 #endif
17465 }
17466 return pyobj;
17467 }
17468
17469
17470 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17471 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17472 return 1;
17473 }
17474
17475
17476 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17477 PyObject *pyobj = 0;
17478
17479 {
17480 #if wxUSE_UNICODE
17481 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17482 #else
17483 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17484 #endif
17485 }
17486 return pyobj;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *resultobj = 0;
17492 wxBMPHandler *result = 0 ;
17493
17494 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (wxBMPHandler *)new wxBMPHandler();
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *obj;
17510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17511 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17512 return SWIG_Py_Void();
17513 }
17514
17515 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 return SWIG_Python_InitShadowInstance(args);
17517 }
17518
17519 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *resultobj = 0;
17521 wxICOHandler *result = 0 ;
17522
17523 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (wxICOHandler *)new wxICOHandler();
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *obj;
17539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17540 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17541 return SWIG_Py_Void();
17542 }
17543
17544 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 return SWIG_Python_InitShadowInstance(args);
17546 }
17547
17548 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17549 PyObject *resultobj = 0;
17550 wxCURHandler *result = 0 ;
17551
17552 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (wxCURHandler *)new wxCURHandler();
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 return SWIG_Python_InitShadowInstance(args);
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxANIHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxANIHandler *)new wxANIHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *obj;
17597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17598 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17599 return SWIG_Py_Void();
17600 }
17601
17602 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 return SWIG_Python_InitShadowInstance(args);
17604 }
17605
17606 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxPNGHandler *result = 0 ;
17609
17610 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxPNGHandler *)new wxPNGHandler();
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *obj;
17626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17627 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17628 return SWIG_Py_Void();
17629 }
17630
17631 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 return SWIG_Python_InitShadowInstance(args);
17633 }
17634
17635 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxGIFHandler *result = 0 ;
17638
17639 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxGIFHandler *)new wxGIFHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 PyObject *obj;
17655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17656 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17657 return SWIG_Py_Void();
17658 }
17659
17660 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 return SWIG_Python_InitShadowInstance(args);
17662 }
17663
17664 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *resultobj = 0;
17666 wxPCXHandler *result = 0 ;
17667
17668 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (wxPCXHandler *)new wxPCXHandler();
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17683 PyObject *obj;
17684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17685 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 return SWIG_Python_InitShadowInstance(args);
17691 }
17692
17693 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17694 PyObject *resultobj = 0;
17695 wxJPEGHandler *result = 0 ;
17696
17697 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxJPEGHandler *)new wxJPEGHandler();
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712 PyObject *obj;
17713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17714 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17715 return SWIG_Py_Void();
17716 }
17717
17718 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 return SWIG_Python_InitShadowInstance(args);
17720 }
17721
17722 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17723 PyObject *resultobj = 0;
17724 wxPNMHandler *result = 0 ;
17725
17726 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (wxPNMHandler *)new wxPNMHandler();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17734 return resultobj;
17735 fail:
17736 return NULL;
17737 }
17738
17739
17740 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17741 PyObject *obj;
17742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17744 return SWIG_Py_Void();
17745 }
17746
17747 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17748 return SWIG_Python_InitShadowInstance(args);
17749 }
17750
17751 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17752 PyObject *resultobj = 0;
17753 wxXPMHandler *result = 0 ;
17754
17755 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17756 {
17757 PyThreadState* __tstate = wxPyBeginAllowThreads();
17758 result = (wxXPMHandler *)new wxXPMHandler();
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770 PyObject *obj;
17771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17772 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17773 return SWIG_Py_Void();
17774 }
17775
17776 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17777 return SWIG_Python_InitShadowInstance(args);
17778 }
17779
17780 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17781 PyObject *resultobj = 0;
17782 wxTIFFHandler *result = 0 ;
17783
17784 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (wxTIFFHandler *)new wxTIFFHandler();
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17799 PyObject *obj;
17800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17801 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17802 return SWIG_Py_Void();
17803 }
17804
17805 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 return SWIG_Python_InitShadowInstance(args);
17807 }
17808
17809 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxImage *arg1 = 0 ;
17812 wxImage *arg2 = 0 ;
17813 int arg3 = (int) 236 ;
17814 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17815 bool result;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 void *argp2 = 0 ;
17819 int res2 = 0 ;
17820 int val3 ;
17821 int ecode3 = 0 ;
17822 int val4 ;
17823 int ecode4 = 0 ;
17824 PyObject * obj0 = 0 ;
17825 PyObject * obj1 = 0 ;
17826 PyObject * obj2 = 0 ;
17827 PyObject * obj3 = 0 ;
17828 char * kwnames[] = {
17829 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17830 };
17831
17832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17833 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17834 if (!SWIG_IsOK(res1)) {
17835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17836 }
17837 if (!argp1) {
17838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17839 }
17840 arg1 = reinterpret_cast< wxImage * >(argp1);
17841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17842 if (!SWIG_IsOK(res2)) {
17843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17844 }
17845 if (!argp2) {
17846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17847 }
17848 arg2 = reinterpret_cast< wxImage * >(argp2);
17849 if (obj2) {
17850 ecode3 = SWIG_AsVal_int(obj2, &val3);
17851 if (!SWIG_IsOK(ecode3)) {
17852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17853 }
17854 arg3 = static_cast< int >(val3);
17855 }
17856 if (obj3) {
17857 ecode4 = SWIG_AsVal_int(obj3, &val4);
17858 if (!SWIG_IsOK(ecode4)) {
17859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17860 }
17861 arg4 = static_cast< int >(val4);
17862 }
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17879 PyObject *obj;
17880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17881 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17882 return SWIG_Py_Void();
17883 }
17884
17885 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17886 PyObject *resultobj = 0;
17887 wxEvtHandler *result = 0 ;
17888
17889 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (wxEvtHandler *)new wxEvtHandler();
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17904 PyObject *resultobj = 0;
17905 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17906 wxEvtHandler *result = 0 ;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 PyObject *swig_obj[1] ;
17910
17911 if (!args) SWIG_fail;
17912 swig_obj[0] = args;
17913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17914 if (!SWIG_IsOK(res1)) {
17915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17916 }
17917 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17918 {
17919 PyThreadState* __tstate = wxPyBeginAllowThreads();
17920 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 resultobj = wxPyMake_wxObject(result, 0);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17936 wxEvtHandler *result = 0 ;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17946 }
17947 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 resultobj = wxPyMake_wxObject(result, 0);
17956 }
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17964 PyObject *resultobj = 0;
17965 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17966 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 void *argp2 = 0 ;
17970 int res2 = 0 ;
17971 PyObject * obj0 = 0 ;
17972 PyObject * obj1 = 0 ;
17973 char * kwnames[] = {
17974 (char *) "self",(char *) "handler", NULL
17975 };
17976
17977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17979 if (!SWIG_IsOK(res1)) {
17980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17981 }
17982 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17984 if (!SWIG_IsOK(res2)) {
17985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17986 }
17987 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 (arg1)->SetNextHandler(arg2);
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 resultobj = SWIG_Py_Void();
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18002 PyObject *resultobj = 0;
18003 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18004 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18005 void *argp1 = 0 ;
18006 int res1 = 0 ;
18007 void *argp2 = 0 ;
18008 int res2 = 0 ;
18009 PyObject * obj0 = 0 ;
18010 PyObject * obj1 = 0 ;
18011 char * kwnames[] = {
18012 (char *) "self",(char *) "handler", NULL
18013 };
18014
18015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18019 }
18020 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18022 if (!SWIG_IsOK(res2)) {
18023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18024 }
18025 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18026 {
18027 PyThreadState* __tstate = wxPyBeginAllowThreads();
18028 (arg1)->SetPreviousHandler(arg2);
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_Py_Void();
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18040 PyObject *resultobj = 0;
18041 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18042 bool result;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 PyObject *swig_obj[1] ;
18046
18047 if (!args) SWIG_fail;
18048 swig_obj[0] = args;
18049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18052 }
18053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (bool)(arg1)->GetEvtHandlerEnabled();
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 {
18061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18062 }
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = 0;
18071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18072 bool arg2 ;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 bool val2 ;
18076 int ecode2 = 0 ;
18077 PyObject * obj0 = 0 ;
18078 PyObject * obj1 = 0 ;
18079 char * kwnames[] = {
18080 (char *) "self",(char *) "enabled", NULL
18081 };
18082
18083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18087 }
18088 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18090 if (!SWIG_IsOK(ecode2)) {
18091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18092 }
18093 arg2 = static_cast< bool >(val2);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 (arg1)->SetEvtHandlerEnabled(arg2);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = SWIG_Py_Void();
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj = 0;
18109 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18110 wxEvent *arg2 = 0 ;
18111 bool result;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 void *argp2 = 0 ;
18115 int res2 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 char * kwnames[] = {
18119 (char *) "self",(char *) "event", NULL
18120 };
18121
18122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18124 if (!SWIG_IsOK(res1)) {
18125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18126 }
18127 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18129 if (!SWIG_IsOK(res2)) {
18130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18131 }
18132 if (!argp2) {
18133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18134 }
18135 arg2 = reinterpret_cast< wxEvent * >(argp2);
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (bool)(arg1)->ProcessEvent(*arg2);
18139 wxPyEndAllowThreads(__tstate);
18140 if (PyErr_Occurred()) SWIG_fail;
18141 }
18142 {
18143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18144 }
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj = 0;
18153 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18154 wxEvent *arg2 = 0 ;
18155 void *argp1 = 0 ;
18156 int res1 = 0 ;
18157 void *argp2 = 0 ;
18158 int res2 = 0 ;
18159 PyObject * obj0 = 0 ;
18160 PyObject * obj1 = 0 ;
18161 char * kwnames[] = {
18162 (char *) "self",(char *) "event", NULL
18163 };
18164
18165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18169 }
18170 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18172 if (!SWIG_IsOK(res2)) {
18173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18174 }
18175 if (!argp2) {
18176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18177 }
18178 arg2 = reinterpret_cast< wxEvent * >(argp2);
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 (arg1)->AddPendingEvent(*arg2);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = SWIG_Py_Void();
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18193 PyObject *resultobj = 0;
18194 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18204 }
18205 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->ProcessPendingEvents();
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18222 int arg2 ;
18223 int arg3 ;
18224 int arg4 ;
18225 PyObject *arg5 = (PyObject *) 0 ;
18226 void *argp1 = 0 ;
18227 int res1 = 0 ;
18228 int val2 ;
18229 int ecode2 = 0 ;
18230 int val3 ;
18231 int ecode3 = 0 ;
18232 int val4 ;
18233 int ecode4 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 PyObject * obj2 = 0 ;
18237 PyObject * obj3 = 0 ;
18238 PyObject * obj4 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18252 }
18253 arg2 = static_cast< int >(val2);
18254 ecode3 = SWIG_AsVal_int(obj2, &val3);
18255 if (!SWIG_IsOK(ecode3)) {
18256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18257 }
18258 arg3 = static_cast< int >(val3);
18259 ecode4 = SWIG_AsVal_int(obj3, &val4);
18260 if (!SWIG_IsOK(ecode4)) {
18261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18262 }
18263 arg4 = static_cast< int >(val4);
18264 arg5 = obj4;
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_Py_Void();
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18281 int arg2 ;
18282 int arg3 = (int) -1 ;
18283 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 int val2 ;
18288 int ecode2 = 0 ;
18289 int val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18305 }
18306 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18307 ecode2 = SWIG_AsVal_int(obj1, &val2);
18308 if (!SWIG_IsOK(ecode2)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18310 }
18311 arg2 = static_cast< int >(val2);
18312 if (obj2) {
18313 ecode3 = SWIG_AsVal_int(obj2, &val3);
18314 if (!SWIG_IsOK(ecode3)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18316 }
18317 arg3 = static_cast< int >(val3);
18318 }
18319 if (obj3) {
18320 ecode4 = SWIG_AsVal_int(obj3, &val4);
18321 if (!SWIG_IsOK(ecode4)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18323 }
18324 arg4 = static_cast< wxEventType >(val4);
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = 0;
18343 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18344 PyObject *arg2 = (PyObject *) 0 ;
18345 bool arg3 = (bool) true ;
18346 void *argp1 = 0 ;
18347 int res1 = 0 ;
18348 bool val3 ;
18349 int ecode3 = 0 ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 PyObject * obj2 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "_self",(char *) "incref", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18361 }
18362 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18363 arg2 = obj1;
18364 if (obj2) {
18365 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18366 if (!SWIG_IsOK(ecode3)) {
18367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18368 }
18369 arg3 = static_cast< bool >(val3);
18370 }
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18385 PyObject *obj;
18386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18387 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18388 return SWIG_Py_Void();
18389 }
18390
18391 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18392 return SWIG_Python_InitShadowInstance(args);
18393 }
18394
18395 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18396 PyObject *resultobj = 0;
18397 wxEventType result;
18398
18399 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (wxEventType)wxNewEventType();
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_From_int(static_cast< int >(result));
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18414 PyObject *resultobj = 0;
18415 wxEvent *arg1 = (wxEvent *) 0 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 PyObject *swig_obj[1] ;
18419
18420 if (!args) SWIG_fail;
18421 swig_obj[0] = args;
18422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 {
18428 PyThreadState* __tstate = wxPyBeginAllowThreads();
18429 delete arg1;
18430
18431 wxPyEndAllowThreads(__tstate);
18432 if (PyErr_Occurred()) SWIG_fail;
18433 }
18434 resultobj = SWIG_Py_Void();
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = 0;
18443 wxEvent *arg1 = (wxEvent *) 0 ;
18444 wxEventType arg2 ;
18445 void *argp1 = 0 ;
18446 int res1 = 0 ;
18447 int val2 ;
18448 int ecode2 = 0 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 char * kwnames[] = {
18452 (char *) "self",(char *) "typ", NULL
18453 };
18454
18455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 ecode2 = SWIG_AsVal_int(obj1, &val2);
18462 if (!SWIG_IsOK(ecode2)) {
18463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18464 }
18465 arg2 = static_cast< wxEventType >(val2);
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 (arg1)->SetEventType(arg2);
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 resultobj = SWIG_Py_Void();
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 wxEventType result;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 PyObject *swig_obj[1] ;
18486
18487 if (!args) SWIG_fail;
18488 swig_obj[0] = args;
18489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18497 wxPyEndAllowThreads(__tstate);
18498 if (PyErr_Occurred()) SWIG_fail;
18499 }
18500 resultobj = SWIG_From_int(static_cast< int >(result));
18501 return resultobj;
18502 fail:
18503 return NULL;
18504 }
18505
18506
18507 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18508 PyObject *resultobj = 0;
18509 wxEvent *arg1 = (wxEvent *) 0 ;
18510 wxObject *result = 0 ;
18511 void *argp1 = 0 ;
18512 int res1 = 0 ;
18513 PyObject *swig_obj[1] ;
18514
18515 if (!args) SWIG_fail;
18516 swig_obj[0] = args;
18517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18518 if (!SWIG_IsOK(res1)) {
18519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18520 }
18521 arg1 = reinterpret_cast< wxEvent * >(argp1);
18522 {
18523 PyThreadState* __tstate = wxPyBeginAllowThreads();
18524 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18525 wxPyEndAllowThreads(__tstate);
18526 if (PyErr_Occurred()) SWIG_fail;
18527 }
18528 {
18529 resultobj = wxPyMake_wxObject(result, (bool)0);
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj = 0;
18539 wxEvent *arg1 = (wxEvent *) 0 ;
18540 wxObject *arg2 = (wxObject *) 0 ;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 void *argp2 = 0 ;
18544 int res2 = 0 ;
18545 PyObject * obj0 = 0 ;
18546 PyObject * obj1 = 0 ;
18547 char * kwnames[] = {
18548 (char *) "self",(char *) "obj", NULL
18549 };
18550
18551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18553 if (!SWIG_IsOK(res1)) {
18554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18555 }
18556 arg1 = reinterpret_cast< wxEvent * >(argp1);
18557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18558 if (!SWIG_IsOK(res2)) {
18559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18560 }
18561 arg2 = reinterpret_cast< wxObject * >(argp2);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 (arg1)->SetEventObject(arg2);
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 resultobj = SWIG_Py_Void();
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18576 PyObject *resultobj = 0;
18577 wxEvent *arg1 = (wxEvent *) 0 ;
18578 long result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 PyObject *swig_obj[1] ;
18582
18583 if (!args) SWIG_fail;
18584 swig_obj[0] = args;
18585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18586 if (!SWIG_IsOK(res1)) {
18587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18588 }
18589 arg1 = reinterpret_cast< wxEvent * >(argp1);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_From_long(static_cast< long >(result));
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj = 0;
18605 wxEvent *arg1 = (wxEvent *) 0 ;
18606 long arg2 = (long) 0 ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 long val2 ;
18610 int ecode2 = 0 ;
18611 PyObject * obj0 = 0 ;
18612 PyObject * obj1 = 0 ;
18613 char * kwnames[] = {
18614 (char *) "self",(char *) "ts", NULL
18615 };
18616
18617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18619 if (!SWIG_IsOK(res1)) {
18620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18621 }
18622 arg1 = reinterpret_cast< wxEvent * >(argp1);
18623 if (obj1) {
18624 ecode2 = SWIG_AsVal_long(obj1, &val2);
18625 if (!SWIG_IsOK(ecode2)) {
18626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18627 }
18628 arg2 = static_cast< long >(val2);
18629 }
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 (arg1)->SetTimestamp(arg2);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_Py_Void();
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxEvent *arg1 = (wxEvent *) 0 ;
18646 int result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)((wxEvent const *)arg1)->GetId();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_From_int(static_cast< int >(result));
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj = 0;
18673 wxEvent *arg1 = (wxEvent *) 0 ;
18674 int arg2 ;
18675 void *argp1 = 0 ;
18676 int res1 = 0 ;
18677 int val2 ;
18678 int ecode2 = 0 ;
18679 PyObject * obj0 = 0 ;
18680 PyObject * obj1 = 0 ;
18681 char * kwnames[] = {
18682 (char *) "self",(char *) "Id", NULL
18683 };
18684
18685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18687 if (!SWIG_IsOK(res1)) {
18688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18689 }
18690 arg1 = reinterpret_cast< wxEvent * >(argp1);
18691 ecode2 = SWIG_AsVal_int(obj1, &val2);
18692 if (!SWIG_IsOK(ecode2)) {
18693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18694 }
18695 arg2 = static_cast< int >(val2);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 (arg1)->SetId(arg2);
18699 wxPyEndAllowThreads(__tstate);
18700 if (PyErr_Occurred()) SWIG_fail;
18701 }
18702 resultobj = SWIG_Py_Void();
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxEvent *arg1 = (wxEvent *) 0 ;
18712 bool result;
18713 void *argp1 = 0 ;
18714 int res1 = 0 ;
18715 PyObject *swig_obj[1] ;
18716
18717 if (!args) SWIG_fail;
18718 swig_obj[0] = args;
18719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 {
18731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj = 0;
18741 wxEvent *arg1 = (wxEvent *) 0 ;
18742 bool arg2 = (bool) true ;
18743 void *argp1 = 0 ;
18744 int res1 = 0 ;
18745 bool val2 ;
18746 int ecode2 = 0 ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "self",(char *) "skip", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18757 }
18758 arg1 = reinterpret_cast< wxEvent * >(argp1);
18759 if (obj1) {
18760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18761 if (!SWIG_IsOK(ecode2)) {
18762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18763 }
18764 arg2 = static_cast< bool >(val2);
18765 }
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 (arg1)->Skip(arg2);
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_Py_Void();
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18780 PyObject *resultobj = 0;
18781 wxEvent *arg1 = (wxEvent *) 0 ;
18782 bool result;
18783 void *argp1 = 0 ;
18784 int res1 = 0 ;
18785 PyObject *swig_obj[1] ;
18786
18787 if (!args) SWIG_fail;
18788 swig_obj[0] = args;
18789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18790 if (!SWIG_IsOK(res1)) {
18791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18792 }
18793 arg1 = reinterpret_cast< wxEvent * >(argp1);
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 {
18801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18802 }
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18810 PyObject *resultobj = 0;
18811 wxEvent *arg1 = (wxEvent *) 0 ;
18812 bool result;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 PyObject *swig_obj[1] ;
18816
18817 if (!args) SWIG_fail;
18818 swig_obj[0] = args;
18819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18820 if (!SWIG_IsOK(res1)) {
18821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18822 }
18823 arg1 = reinterpret_cast< wxEvent * >(argp1);
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 {
18831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18832 }
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 PyObject *resultobj = 0;
18841 wxEvent *arg1 = (wxEvent *) 0 ;
18842 int result;
18843 void *argp1 = 0 ;
18844 int res1 = 0 ;
18845 PyObject *swig_obj[1] ;
18846
18847 if (!args) SWIG_fail;
18848 swig_obj[0] = args;
18849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18850 if (!SWIG_IsOK(res1)) {
18851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18852 }
18853 arg1 = reinterpret_cast< wxEvent * >(argp1);
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (int)(arg1)->StopPropagation();
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_From_int(static_cast< int >(result));
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj = 0;
18869 wxEvent *arg1 = (wxEvent *) 0 ;
18870 int arg2 ;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 int val2 ;
18874 int ecode2 = 0 ;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char * kwnames[] = {
18878 (char *) "self",(char *) "propagationLevel", NULL
18879 };
18880
18881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18883 if (!SWIG_IsOK(res1)) {
18884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18885 }
18886 arg1 = reinterpret_cast< wxEvent * >(argp1);
18887 ecode2 = SWIG_AsVal_int(obj1, &val2);
18888 if (!SWIG_IsOK(ecode2)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18890 }
18891 arg2 = static_cast< int >(val2);
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 (arg1)->ResumePropagation(arg2);
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 resultobj = SWIG_Py_Void();
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18906 PyObject *resultobj = 0;
18907 wxEvent *arg1 = (wxEvent *) 0 ;
18908 wxEvent *result = 0 ;
18909 void *argp1 = 0 ;
18910 int res1 = 0 ;
18911 PyObject *swig_obj[1] ;
18912
18913 if (!args) SWIG_fail;
18914 swig_obj[0] = args;
18915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18916 if (!SWIG_IsOK(res1)) {
18917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18918 }
18919 arg1 = reinterpret_cast< wxEvent * >(argp1);
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (wxEvent *)(arg1)->Clone();
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 PyObject *obj;
18935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18936 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18937 return SWIG_Py_Void();
18938 }
18939
18940 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18941 PyObject *resultobj = 0;
18942 wxEvent *arg1 = 0 ;
18943 wxPropagationDisabler *result = 0 ;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject * obj0 = 0 ;
18947 char * kwnames[] = {
18948 (char *) "event", NULL
18949 };
18950
18951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18952 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18953 if (!SWIG_IsOK(res1)) {
18954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18955 }
18956 if (!argp1) {
18957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18958 }
18959 arg1 = reinterpret_cast< wxEvent * >(argp1);
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974 PyObject *resultobj = 0;
18975 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18976 void *argp1 = 0 ;
18977 int res1 = 0 ;
18978 PyObject *swig_obj[1] ;
18979
18980 if (!args) SWIG_fail;
18981 swig_obj[0] = args;
18982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18985 }
18986 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 delete arg1;
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 resultobj = SWIG_Py_Void();
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19002 PyObject *obj;
19003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19005 return SWIG_Py_Void();
19006 }
19007
19008 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19009 return SWIG_Python_InitShadowInstance(args);
19010 }
19011
19012 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxEvent *arg1 = 0 ;
19015 wxPropagateOnce *result = 0 ;
19016 void *argp1 = 0 ;
19017 int res1 = 0 ;
19018 PyObject * obj0 = 0 ;
19019 char * kwnames[] = {
19020 (char *) "event", NULL
19021 };
19022
19023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19024 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19025 if (!SWIG_IsOK(res1)) {
19026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19027 }
19028 if (!argp1) {
19029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19046 PyObject *resultobj = 0;
19047 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 PyObject *swig_obj[1] ;
19051
19052 if (!args) SWIG_fail;
19053 swig_obj[0] = args;
19054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19055 if (!SWIG_IsOK(res1)) {
19056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19057 }
19058 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 delete arg1;
19062
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_Py_Void();
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074 PyObject *obj;
19075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19077 return SWIG_Py_Void();
19078 }
19079
19080 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19081 return SWIG_Python_InitShadowInstance(args);
19082 }
19083
19084 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19085 PyObject *resultobj = 0;
19086 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19087 int arg2 = (int) 0 ;
19088 wxCommandEvent *result = 0 ;
19089 int val1 ;
19090 int ecode1 = 0 ;
19091 int val2 ;
19092 int ecode2 = 0 ;
19093 PyObject * obj0 = 0 ;
19094 PyObject * obj1 = 0 ;
19095 char * kwnames[] = {
19096 (char *) "commandType",(char *) "winid", NULL
19097 };
19098
19099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19100 if (obj0) {
19101 ecode1 = SWIG_AsVal_int(obj0, &val1);
19102 if (!SWIG_IsOK(ecode1)) {
19103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19104 }
19105 arg1 = static_cast< wxEventType >(val1);
19106 }
19107 if (obj1) {
19108 ecode2 = SWIG_AsVal_int(obj1, &val2);
19109 if (!SWIG_IsOK(ecode2)) {
19110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19111 }
19112 arg2 = static_cast< int >(val2);
19113 }
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 int result;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19140 }
19141 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 resultobj = SWIG_From_int(static_cast< int >(result));
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj = 0;
19157 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19158 wxString *arg2 = 0 ;
19159 void *argp1 = 0 ;
19160 int res1 = 0 ;
19161 bool temp2 = false ;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 char * kwnames[] = {
19165 (char *) "self",(char *) "s", NULL
19166 };
19167
19168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 arg2 = wxString_in_helper(obj1);
19176 if (arg2 == NULL) SWIG_fail;
19177 temp2 = true;
19178 }
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 (arg1)->SetString((wxString const &)*arg2);
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 resultobj = SWIG_Py_Void();
19186 {
19187 if (temp2)
19188 delete arg2;
19189 }
19190 return resultobj;
19191 fail:
19192 {
19193 if (temp2)
19194 delete arg2;
19195 }
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *resultobj = 0;
19202 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19203 wxString result;
19204 void *argp1 = 0 ;
19205 int res1 = 0 ;
19206 PyObject *swig_obj[1] ;
19207
19208 if (!args) SWIG_fail;
19209 swig_obj[0] = args;
19210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 result = ((wxCommandEvent const *)arg1)->GetString();
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 {
19222 #if wxUSE_UNICODE
19223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19224 #else
19225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19226 #endif
19227 }
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19235 PyObject *resultobj = 0;
19236 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19237 bool result;
19238 void *argp1 = 0 ;
19239 int res1 = 0 ;
19240 PyObject *swig_obj[1] ;
19241
19242 if (!args) SWIG_fail;
19243 swig_obj[0] = args;
19244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19245 if (!SWIG_IsOK(res1)) {
19246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19247 }
19248 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19265 PyObject *resultobj = 0;
19266 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19267 bool result;
19268 void *argp1 = 0 ;
19269 int res1 = 0 ;
19270 PyObject *swig_obj[1] ;
19271
19272 if (!args) SWIG_fail;
19273 swig_obj[0] = args;
19274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = 0;
19296 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19297 long arg2 ;
19298 void *argp1 = 0 ;
19299 int res1 = 0 ;
19300 long val2 ;
19301 int ecode2 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 char * kwnames[] = {
19305 (char *) "self",(char *) "extraLong", NULL
19306 };
19307
19308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19310 if (!SWIG_IsOK(res1)) {
19311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19312 }
19313 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19314 ecode2 = SWIG_AsVal_long(obj1, &val2);
19315 if (!SWIG_IsOK(ecode2)) {
19316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19317 }
19318 arg2 = static_cast< long >(val2);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetExtraLong(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_Py_Void();
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 PyObject *resultobj = 0;
19334 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19335 long result;
19336 void *argp1 = 0 ;
19337 int res1 = 0 ;
19338 PyObject *swig_obj[1] ;
19339
19340 if (!args) SWIG_fail;
19341 swig_obj[0] = args;
19342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19343 if (!SWIG_IsOK(res1)) {
19344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19345 }
19346 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_From_long(static_cast< long >(result));
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj = 0;
19362 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19363 int arg2 ;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 int val2 ;
19367 int ecode2 = 0 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 char * kwnames[] = {
19371 (char *) "self",(char *) "i", NULL
19372 };
19373
19374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19376 if (!SWIG_IsOK(res1)) {
19377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19378 }
19379 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19380 ecode2 = SWIG_AsVal_int(obj1, &val2);
19381 if (!SWIG_IsOK(ecode2)) {
19382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19383 }
19384 arg2 = static_cast< int >(val2);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetInt(arg2);
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19401 int result;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject *swig_obj[1] ;
19405
19406 if (!args) SWIG_fail;
19407 swig_obj[0] = args;
19408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19411 }
19412 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_From_int(static_cast< int >(result));
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19429 PyObject *result = 0 ;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 resultobj = result;
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19455 PyObject *resultobj = 0;
19456 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19457 PyObject *arg2 = (PyObject *) 0 ;
19458 void *argp1 = 0 ;
19459 int res1 = 0 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 char * kwnames[] = {
19463 (char *) "self",(char *) "clientData", NULL
19464 };
19465
19466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19470 }
19471 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19472 arg2 = obj1;
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 wxCommandEvent_SetClientData(arg1,arg2);
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_Py_Void();
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19489 wxEvent *result = 0 ;
19490 void *argp1 = 0 ;
19491 int res1 = 0 ;
19492 PyObject *swig_obj[1] ;
19493
19494 if (!args) SWIG_fail;
19495 swig_obj[0] = args;
19496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19497 if (!SWIG_IsOK(res1)) {
19498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19499 }
19500 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 PyObject *obj;
19516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19517 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19518 return SWIG_Py_Void();
19519 }
19520
19521 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 return SWIG_Python_InitShadowInstance(args);
19523 }
19524
19525 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19528 int arg2 = (int) 0 ;
19529 wxNotifyEvent *result = 0 ;
19530 int val1 ;
19531 int ecode1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char * kwnames[] = {
19537 (char *) "commandType",(char *) "winid", NULL
19538 };
19539
19540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19541 if (obj0) {
19542 ecode1 = SWIG_AsVal_int(obj0, &val1);
19543 if (!SWIG_IsOK(ecode1)) {
19544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19545 }
19546 arg1 = static_cast< wxEventType >(val1);
19547 }
19548 if (obj1) {
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19552 }
19553 arg2 = static_cast< int >(val2);
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19569 PyObject *resultobj = 0;
19570 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19571 void *argp1 = 0 ;
19572 int res1 = 0 ;
19573 PyObject *swig_obj[1] ;
19574
19575 if (!args) SWIG_fail;
19576 swig_obj[0] = args;
19577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 (arg1)->Veto();
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 resultobj = SWIG_Py_Void();
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *resultobj = 0;
19597 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19598 void *argp1 = 0 ;
19599 int res1 = 0 ;
19600 PyObject *swig_obj[1] ;
19601
19602 if (!args) SWIG_fail;
19603 swig_obj[0] = args;
19604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19605 if (!SWIG_IsOK(res1)) {
19606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19607 }
19608 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 (arg1)->Allow();
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_Py_Void();
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 PyObject *resultobj = 0;
19624 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19625 bool result;
19626 void *argp1 = 0 ;
19627 int res1 = 0 ;
19628 PyObject *swig_obj[1] ;
19629
19630 if (!args) SWIG_fail;
19631 swig_obj[0] = args;
19632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = (bool)(arg1)->IsAllowed();
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 {
19644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19645 }
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 PyObject *obj;
19654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19655 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19656 return SWIG_Py_Void();
19657 }
19658
19659 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19660 return SWIG_Python_InitShadowInstance(args);
19661 }
19662
19663 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = 0;
19665 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19666 int arg2 = (int) 0 ;
19667 int arg3 = (int) 0 ;
19668 int arg4 = (int) 0 ;
19669 wxScrollEvent *result = 0 ;
19670 int val1 ;
19671 int ecode1 = 0 ;
19672 int val2 ;
19673 int ecode2 = 0 ;
19674 int val3 ;
19675 int ecode3 = 0 ;
19676 int val4 ;
19677 int ecode4 = 0 ;
19678 PyObject * obj0 = 0 ;
19679 PyObject * obj1 = 0 ;
19680 PyObject * obj2 = 0 ;
19681 PyObject * obj3 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 if (obj1) {
19695 ecode2 = SWIG_AsVal_int(obj1, &val2);
19696 if (!SWIG_IsOK(ecode2)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19698 }
19699 arg2 = static_cast< int >(val2);
19700 }
19701 if (obj2) {
19702 ecode3 = SWIG_AsVal_int(obj2, &val3);
19703 if (!SWIG_IsOK(ecode3)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19705 }
19706 arg3 = static_cast< int >(val3);
19707 }
19708 if (obj3) {
19709 ecode4 = SWIG_AsVal_int(obj3, &val4);
19710 if (!SWIG_IsOK(ecode4)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19712 }
19713 arg4 = static_cast< int >(val4);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 int arg2 = (int) 0 ;
19875 int arg3 = (int) 0 ;
19876 wxScrollWinEvent *result = 0 ;
19877 int val1 ;
19878 int ecode1 = 0 ;
19879 int val2 ;
19880 int ecode2 = 0 ;
19881 int val3 ;
19882 int ecode3 = 0 ;
19883 PyObject * obj0 = 0 ;
19884 PyObject * obj1 = 0 ;
19885 PyObject * obj2 = 0 ;
19886 char * kwnames[] = {
19887 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19888 };
19889
19890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19891 if (obj0) {
19892 ecode1 = SWIG_AsVal_int(obj0, &val1);
19893 if (!SWIG_IsOK(ecode1)) {
19894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19895 }
19896 arg1 = static_cast< wxEventType >(val1);
19897 }
19898 if (obj1) {
19899 ecode2 = SWIG_AsVal_int(obj1, &val2);
19900 if (!SWIG_IsOK(ecode2)) {
19901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19902 }
19903 arg2 = static_cast< int >(val2);
19904 }
19905 if (obj2) {
19906 ecode3 = SWIG_AsVal_int(obj2, &val3);
19907 if (!SWIG_IsOK(ecode3)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19909 }
19910 arg3 = static_cast< int >(val3);
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19926 PyObject *resultobj = 0;
19927 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19928 int result;
19929 void *argp1 = 0 ;
19930 int res1 = 0 ;
19931 PyObject *swig_obj[1] ;
19932
19933 if (!args) SWIG_fail;
19934 swig_obj[0] = args;
19935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_From_int(static_cast< int >(result));
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19954 PyObject *resultobj = 0;
19955 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19956 int result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 PyObject *swig_obj[1] ;
19960
19961 if (!args) SWIG_fail;
19962 swig_obj[0] = args;
19963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19964 if (!SWIG_IsOK(res1)) {
19965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19966 }
19967 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_From_int(static_cast< int >(result));
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj = 0;
19983 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19984 int arg2 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 int val2 ;
19988 int ecode2 = 0 ;
19989 PyObject * obj0 = 0 ;
19990 PyObject * obj1 = 0 ;
19991 char * kwnames[] = {
19992 (char *) "self",(char *) "orient", NULL
19993 };
19994
19995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19997 if (!SWIG_IsOK(res1)) {
19998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19999 }
20000 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20001 ecode2 = SWIG_AsVal_int(obj1, &val2);
20002 if (!SWIG_IsOK(ecode2)) {
20003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20004 }
20005 arg2 = static_cast< int >(val2);
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 (arg1)->SetOrientation(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 resultobj = SWIG_Py_Void();
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj = 0;
20021 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20022 int arg2 ;
20023 void *argp1 = 0 ;
20024 int res1 = 0 ;
20025 int val2 ;
20026 int ecode2 = 0 ;
20027 PyObject * obj0 = 0 ;
20028 PyObject * obj1 = 0 ;
20029 char * kwnames[] = {
20030 (char *) "self",(char *) "pos", NULL
20031 };
20032
20033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20035 if (!SWIG_IsOK(res1)) {
20036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20037 }
20038 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20039 ecode2 = SWIG_AsVal_int(obj1, &val2);
20040 if (!SWIG_IsOK(ecode2)) {
20041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20042 }
20043 arg2 = static_cast< int >(val2);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 (arg1)->SetPosition(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 *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *obj;
20059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20060 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20061 return SWIG_Py_Void();
20062 }
20063
20064 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20065 return SWIG_Python_InitShadowInstance(args);
20066 }
20067
20068 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20069 PyObject *resultobj = 0;
20070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20071 wxMouseEvent *result = 0 ;
20072 int val1 ;
20073 int ecode1 = 0 ;
20074 PyObject * obj0 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "mouseType", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20080 if (obj0) {
20081 ecode1 = SWIG_AsVal_int(obj0, &val1);
20082 if (!SWIG_IsOK(ecode1)) {
20083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20084 }
20085 arg1 = static_cast< wxEventType >(val1);
20086 }
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 bool result;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 PyObject *swig_obj[1] ;
20109
20110 if (!args) SWIG_fail;
20111 swig_obj[0] = args;
20112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20113 if (!SWIG_IsOK(res1)) {
20114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20115 }
20116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj = 0;
20134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20135 int arg2 = (int) wxMOUSE_BTN_ANY ;
20136 bool result;
20137 void *argp1 = 0 ;
20138 int res1 = 0 ;
20139 int val2 ;
20140 int ecode2 = 0 ;
20141 PyObject * obj0 = 0 ;
20142 PyObject * obj1 = 0 ;
20143 char * kwnames[] = {
20144 (char *) "self",(char *) "but", NULL
20145 };
20146
20147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20151 }
20152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20153 if (obj1) {
20154 ecode2 = SWIG_AsVal_int(obj1, &val2);
20155 if (!SWIG_IsOK(ecode2)) {
20156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20157 }
20158 arg2 = static_cast< int >(val2);
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 int arg2 = (int) wxMOUSE_BTN_ANY ;
20179 bool result;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 int val2 ;
20183 int ecode2 = 0 ;
20184 PyObject * obj0 = 0 ;
20185 PyObject * obj1 = 0 ;
20186 char * kwnames[] = {
20187 (char *) "self",(char *) "but", NULL
20188 };
20189
20190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20194 }
20195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20196 if (obj1) {
20197 ecode2 = SWIG_AsVal_int(obj1, &val2);
20198 if (!SWIG_IsOK(ecode2)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20200 }
20201 arg2 = static_cast< int >(val2);
20202 }
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20219 PyObject *resultobj = 0;
20220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20221 int arg2 = (int) wxMOUSE_BTN_ANY ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 int val2 ;
20226 int ecode2 = 0 ;
20227 PyObject * obj0 = 0 ;
20228 PyObject * obj1 = 0 ;
20229 char * kwnames[] = {
20230 (char *) "self",(char *) "but", NULL
20231 };
20232
20233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20235 if (!SWIG_IsOK(res1)) {
20236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20237 }
20238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20239 if (obj1) {
20240 ecode2 = SWIG_AsVal_int(obj1, &val2);
20241 if (!SWIG_IsOK(ecode2)) {
20242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20243 }
20244 arg2 = static_cast< int >(val2);
20245 }
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20254 }
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj = 0;
20263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20264 int arg2 ;
20265 bool result;
20266 void *argp1 = 0 ;
20267 int res1 = 0 ;
20268 int val2 ;
20269 int ecode2 = 0 ;
20270 PyObject * obj0 = 0 ;
20271 PyObject * obj1 = 0 ;
20272 char * kwnames[] = {
20273 (char *) "self",(char *) "button", NULL
20274 };
20275
20276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 int arg2 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 int val2 ;
20310 int ecode2 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 char * kwnames[] = {
20314 (char *) "self",(char *) "but", NULL
20315 };
20316
20317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 ecode2 = SWIG_AsVal_int(obj1, &val2);
20324 if (!SWIG_IsOK(ecode2)) {
20325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20326 }
20327 arg2 = static_cast< int >(val2);
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 {
20335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20336 }
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20346 int result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 resultobj = SWIG_From_int(static_cast< int >(result));
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20372 PyObject *resultobj = 0;
20373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20374 bool result;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 PyObject *swig_obj[1] ;
20378
20379 if (!args) SWIG_fail;
20380 swig_obj[0] = args;
20381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20382 if (!SWIG_IsOK(res1)) {
20383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20384 }
20385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20394 }
20395 return resultobj;
20396 fail:
20397 return NULL;
20398 }
20399
20400
20401 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20402 PyObject *resultobj = 0;
20403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20404 bool result;
20405 void *argp1 = 0 ;
20406 int res1 = 0 ;
20407 PyObject *swig_obj[1] ;
20408
20409 if (!args) SWIG_fail;
20410 swig_obj[0] = args;
20411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20412 if (!SWIG_IsOK(res1)) {
20413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20414 }
20415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20434 bool result;
20435 void *argp1 = 0 ;
20436 int res1 = 0 ;
20437 PyObject *swig_obj[1] ;
20438
20439 if (!args) SWIG_fail;
20440 swig_obj[0] = args;
20441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20442 if (!SWIG_IsOK(res1)) {
20443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20444 }
20445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 {
20453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20454 }
20455 return resultobj;
20456 fail:
20457 return NULL;
20458 }
20459
20460
20461 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20464 bool result;
20465 void *argp1 = 0 ;
20466 int res1 = 0 ;
20467 PyObject *swig_obj[1] ;
20468
20469 if (!args) SWIG_fail;
20470 swig_obj[0] = args;
20471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20472 if (!SWIG_IsOK(res1)) {
20473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20474 }
20475 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20492 PyObject *resultobj = 0;
20493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20494 bool result;
20495 void *argp1 = 0 ;
20496 int res1 = 0 ;
20497 PyObject *swig_obj[1] ;
20498
20499 if (!args) SWIG_fail;
20500 swig_obj[0] = args;
20501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20504 }
20505 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 {
20513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20514 }
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 PyObject *resultobj = 0;
20523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20524 bool result;
20525 void *argp1 = 0 ;
20526 int res1 = 0 ;
20527 PyObject *swig_obj[1] ;
20528
20529 if (!args) SWIG_fail;
20530 swig_obj[0] = args;
20531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20532 if (!SWIG_IsOK(res1)) {
20533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20534 }
20535 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 {
20543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20544 }
20545 return resultobj;
20546 fail:
20547 return NULL;
20548 }
20549
20550
20551 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20552 PyObject *resultobj = 0;
20553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20554 bool result;
20555 void *argp1 = 0 ;
20556 int res1 = 0 ;
20557 PyObject *swig_obj[1] ;
20558
20559 if (!args) SWIG_fail;
20560 swig_obj[0] = args;
20561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20562 if (!SWIG_IsOK(res1)) {
20563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20564 }
20565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20566 {
20567 PyThreadState* __tstate = wxPyBeginAllowThreads();
20568 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 {
20573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20574 }
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582 PyObject *resultobj = 0;
20583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20584 bool result;
20585 void *argp1 = 0 ;
20586 int res1 = 0 ;
20587 PyObject *swig_obj[1] ;
20588
20589 if (!args) SWIG_fail;
20590 swig_obj[0] = args;
20591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20594 }
20595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20612 PyObject *resultobj = 0;
20613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20614 bool result;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 PyObject *swig_obj[1] ;
20618
20619 if (!args) SWIG_fail;
20620 swig_obj[0] = args;
20621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20624 }
20625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20629 wxPyEndAllowThreads(__tstate);
20630 if (PyErr_Occurred()) SWIG_fail;
20631 }
20632 {
20633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20634 }
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *resultobj = 0;
20643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20644 bool result;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 PyObject *swig_obj[1] ;
20648
20649 if (!args) SWIG_fail;
20650 swig_obj[0] = args;
20651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20654 }
20655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20672 PyObject *resultobj = 0;
20673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20674 bool result;
20675 void *argp1 = 0 ;
20676 int res1 = 0 ;
20677 PyObject *swig_obj[1] ;
20678
20679 if (!args) SWIG_fail;
20680 swig_obj[0] = args;
20681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20684 }
20685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20702 PyObject *resultobj = 0;
20703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20704 bool result;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 PyObject *swig_obj[1] ;
20708
20709 if (!args) SWIG_fail;
20710 swig_obj[0] = args;
20711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20712 if (!SWIG_IsOK(res1)) {
20713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20714 }
20715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 {
20723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20724 }
20725 return resultobj;
20726 fail:
20727 return NULL;
20728 }
20729
20730
20731 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20732 PyObject *resultobj = 0;
20733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20734 bool result;
20735 void *argp1 = 0 ;
20736 int res1 = 0 ;
20737 PyObject *swig_obj[1] ;
20738
20739 if (!args) SWIG_fail;
20740 swig_obj[0] = args;
20741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20744 }
20745 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 {
20753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20754 }
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 PyObject *resultobj = 0;
20763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20764 bool result;
20765 void *argp1 = 0 ;
20766 int res1 = 0 ;
20767 PyObject *swig_obj[1] ;
20768
20769 if (!args) SWIG_fail;
20770 swig_obj[0] = args;
20771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20772 if (!SWIG_IsOK(res1)) {
20773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20774 }
20775 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20776 {
20777 PyThreadState* __tstate = wxPyBeginAllowThreads();
20778 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20784 }
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 PyObject *resultobj = 0;
20793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20794 bool result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 PyObject *swig_obj[1] ;
20798
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (bool)(arg1)->LeftIsDown();
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 {
20813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20814 }
20815 return resultobj;
20816 fail:
20817 return NULL;
20818 }
20819
20820
20821 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20822 PyObject *resultobj = 0;
20823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20824 bool result;
20825 void *argp1 = 0 ;
20826 int res1 = 0 ;
20827 PyObject *swig_obj[1] ;
20828
20829 if (!args) SWIG_fail;
20830 swig_obj[0] = args;
20831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20834 }
20835 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (bool)(arg1)->MiddleIsDown();
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 {
20843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20844 }
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20852 PyObject *resultobj = 0;
20853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20854 bool result;
20855 void *argp1 = 0 ;
20856 int res1 = 0 ;
20857 PyObject *swig_obj[1] ;
20858
20859 if (!args) SWIG_fail;
20860 swig_obj[0] = args;
20861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20864 }
20865 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)(arg1)->RightIsDown();
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20874 }
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20884 bool result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 PyObject *swig_obj[1] ;
20888
20889 if (!args) SWIG_fail;
20890 swig_obj[0] = args;
20891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20892 if (!SWIG_IsOK(res1)) {
20893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20894 }
20895 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 {
20903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20904 }
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20914 bool result;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 PyObject *swig_obj[1] ;
20918
20919 if (!args) SWIG_fail;
20920 swig_obj[0] = args;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20924 }
20925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20944 bool result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 PyObject *swig_obj[1] ;
20948
20949 if (!args) SWIG_fail;
20950 swig_obj[0] = args;
20951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20952 if (!SWIG_IsOK(res1)) {
20953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20954 }
20955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 {
20963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20964 }
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *resultobj = 0;
20973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20974 bool result;
20975 void *argp1 = 0 ;
20976 int res1 = 0 ;
20977 PyObject *swig_obj[1] ;
20978
20979 if (!args) SWIG_fail;
20980 swig_obj[0] = args;
20981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20984 }
20985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20989 wxPyEndAllowThreads(__tstate);
20990 if (PyErr_Occurred()) SWIG_fail;
20991 }
20992 {
20993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20994 }
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21002 PyObject *resultobj = 0;
21003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21004 wxPoint result;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 PyObject *swig_obj[1] ;
21008
21009 if (!args) SWIG_fail;
21010 swig_obj[0] = args;
21011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21012 if (!SWIG_IsOK(res1)) {
21013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21014 }
21015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (arg1)->GetPosition();
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21032 long *arg2 = (long *) 0 ;
21033 long *arg3 = (long *) 0 ;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 long temp2 ;
21037 int res2 = SWIG_TMPOBJ ;
21038 long temp3 ;
21039 int res3 = SWIG_TMPOBJ ;
21040 PyObject *swig_obj[1] ;
21041
21042 arg2 = &temp2;
21043 arg3 = &temp3;
21044 if (!args) SWIG_fail;
21045 swig_obj[0] = args;
21046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21047 if (!SWIG_IsOK(res1)) {
21048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21049 }
21050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21051 {
21052 PyThreadState* __tstate = wxPyBeginAllowThreads();
21053 (arg1)->GetPosition(arg2,arg3);
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 resultobj = SWIG_Py_Void();
21058 if (SWIG_IsTmpObj(res2)) {
21059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21060 } else {
21061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21063 }
21064 if (SWIG_IsTmpObj(res3)) {
21065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21066 } else {
21067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 wxDC *arg2 = 0 ;
21080 wxPoint result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 void *argp2 = 0 ;
21084 int res2 = 0 ;
21085 PyObject * obj0 = 0 ;
21086 PyObject * obj1 = 0 ;
21087 char * kwnames[] = {
21088 (char *) "self",(char *) "dc", NULL
21089 };
21090
21091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21098 if (!SWIG_IsOK(res2)) {
21099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21100 }
21101 if (!argp2) {
21102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21103 }
21104 arg2 = reinterpret_cast< wxDC * >(argp2);
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21121 int result;
21122 void *argp1 = 0 ;
21123 int res1 = 0 ;
21124 PyObject *swig_obj[1] ;
21125
21126 if (!args) SWIG_fail;
21127 swig_obj[0] = args;
21128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21129 if (!SWIG_IsOK(res1)) {
21130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21131 }
21132 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (int)((wxMouseEvent const *)arg1)->GetX();
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_From_int(static_cast< int >(result));
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21149 int result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (int)((wxMouseEvent const *)arg1)->GetY();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_From_int(static_cast< int >(result));
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_From_int(static_cast< int >(result));
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21205 int result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_From_int(static_cast< int >(result));
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 int result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 resultobj = SWIG_From_int(static_cast< int >(result));
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 bool result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 int arg2 ;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 int val2 ;
21295 int ecode2 = 0 ;
21296 PyObject *swig_obj[2] ;
21297
21298 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21305 if (!SWIG_IsOK(ecode2)) {
21306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21307 }
21308 arg2 = static_cast< int >(val2);
21309 if (arg1) (arg1)->m_x = arg2;
21310
21311 resultobj = SWIG_Py_Void();
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 int result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 result = (int) ((arg1)->m_x);
21334 resultobj = SWIG_From_int(static_cast< int >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21342 PyObject *resultobj = 0;
21343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21344 int arg2 ;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 int val2 ;
21348 int ecode2 = 0 ;
21349 PyObject *swig_obj[2] ;
21350
21351 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21355 }
21356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21357 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21358 if (!SWIG_IsOK(ecode2)) {
21359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21360 }
21361 arg2 = static_cast< int >(val2);
21362 if (arg1) (arg1)->m_y = arg2;
21363
21364 resultobj = SWIG_Py_Void();
21365 return resultobj;
21366 fail:
21367 return NULL;
21368 }
21369
21370
21371 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21372 PyObject *resultobj = 0;
21373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21374 int result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 PyObject *swig_obj[1] ;
21378
21379 if (!args) SWIG_fail;
21380 swig_obj[0] = args;
21381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21382 if (!SWIG_IsOK(res1)) {
21383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21384 }
21385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21386 result = (int) ((arg1)->m_y);
21387 resultobj = SWIG_From_int(static_cast< int >(result));
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21395 PyObject *resultobj = 0;
21396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21397 bool arg2 ;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 bool val2 ;
21401 int ecode2 = 0 ;
21402 PyObject *swig_obj[2] ;
21403
21404 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21410 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21411 if (!SWIG_IsOK(ecode2)) {
21412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21413 }
21414 arg2 = static_cast< bool >(val2);
21415 if (arg1) (arg1)->m_leftDown = arg2;
21416
21417 resultobj = SWIG_Py_Void();
21418 return resultobj;
21419 fail:
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21425 PyObject *resultobj = 0;
21426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21427 bool result;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 PyObject *swig_obj[1] ;
21431
21432 if (!args) SWIG_fail;
21433 swig_obj[0] = args;
21434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21437 }
21438 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21439 result = (bool) ((arg1)->m_leftDown);
21440 {
21441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21442 }
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21450 PyObject *resultobj = 0;
21451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21452 bool arg2 ;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 bool val2 ;
21456 int ecode2 = 0 ;
21457 PyObject *swig_obj[2] ;
21458
21459 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21463 }
21464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21465 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21466 if (!SWIG_IsOK(ecode2)) {
21467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21468 }
21469 arg2 = static_cast< bool >(val2);
21470 if (arg1) (arg1)->m_middleDown = arg2;
21471
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *resultobj = 0;
21481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21482 bool result;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 PyObject *swig_obj[1] ;
21486
21487 if (!args) SWIG_fail;
21488 swig_obj[0] = args;
21489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21492 }
21493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21494 result = (bool) ((arg1)->m_middleDown);
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 return resultobj;
21499 fail:
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21505 PyObject *resultobj = 0;
21506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21507 bool arg2 ;
21508 void *argp1 = 0 ;
21509 int res1 = 0 ;
21510 bool val2 ;
21511 int ecode2 = 0 ;
21512 PyObject *swig_obj[2] ;
21513
21514 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21520 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21521 if (!SWIG_IsOK(ecode2)) {
21522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21523 }
21524 arg2 = static_cast< bool >(val2);
21525 if (arg1) (arg1)->m_rightDown = arg2;
21526
21527 resultobj = SWIG_Py_Void();
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *resultobj = 0;
21536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21537 bool result;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 PyObject *swig_obj[1] ;
21541
21542 if (!args) SWIG_fail;
21543 swig_obj[0] = args;
21544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21545 if (!SWIG_IsOK(res1)) {
21546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21547 }
21548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21549 result = (bool) ((arg1)->m_rightDown);
21550 {
21551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21552 }
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21560 PyObject *resultobj = 0;
21561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21562 bool arg2 ;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 bool val2 ;
21566 int ecode2 = 0 ;
21567 PyObject *swig_obj[2] ;
21568
21569 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21571 if (!SWIG_IsOK(res1)) {
21572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21573 }
21574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21575 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21576 if (!SWIG_IsOK(ecode2)) {
21577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21578 }
21579 arg2 = static_cast< bool >(val2);
21580 if (arg1) (arg1)->m_controlDown = arg2;
21581
21582 resultobj = SWIG_Py_Void();
21583 return resultobj;
21584 fail:
21585 return NULL;
21586 }
21587
21588
21589 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 PyObject *resultobj = 0;
21591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21592 bool result;
21593 void *argp1 = 0 ;
21594 int res1 = 0 ;
21595 PyObject *swig_obj[1] ;
21596
21597 if (!args) SWIG_fail;
21598 swig_obj[0] = args;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 result = (bool) ((arg1)->m_controlDown);
21605 {
21606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21607 }
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *resultobj = 0;
21616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21617 bool arg2 ;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool val2 ;
21621 int ecode2 = 0 ;
21622 PyObject *swig_obj[2] ;
21623
21624 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21626 if (!SWIG_IsOK(res1)) {
21627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21628 }
21629 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21630 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21631 if (!SWIG_IsOK(ecode2)) {
21632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21633 }
21634 arg2 = static_cast< bool >(val2);
21635 if (arg1) (arg1)->m_shiftDown = arg2;
21636
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21647 bool result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21659 result = (bool) ((arg1)->m_shiftDown);
21660 {
21661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21662 }
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *resultobj = 0;
21671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21672 bool arg2 ;
21673 void *argp1 = 0 ;
21674 int res1 = 0 ;
21675 bool val2 ;
21676 int ecode2 = 0 ;
21677 PyObject *swig_obj[2] ;
21678
21679 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21683 }
21684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21685 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21686 if (!SWIG_IsOK(ecode2)) {
21687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21688 }
21689 arg2 = static_cast< bool >(val2);
21690 if (arg1) (arg1)->m_altDown = arg2;
21691
21692 resultobj = SWIG_Py_Void();
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 PyObject *resultobj = 0;
21701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21702 bool result;
21703 void *argp1 = 0 ;
21704 int res1 = 0 ;
21705 PyObject *swig_obj[1] ;
21706
21707 if (!args) SWIG_fail;
21708 swig_obj[0] = args;
21709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21712 }
21713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21714 result = (bool) ((arg1)->m_altDown);
21715 {
21716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21717 }
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *resultobj = 0;
21726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21727 bool arg2 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 bool val2 ;
21731 int ecode2 = 0 ;
21732 PyObject *swig_obj[2] ;
21733
21734 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21736 if (!SWIG_IsOK(res1)) {
21737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21738 }
21739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21740 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21741 if (!SWIG_IsOK(ecode2)) {
21742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21743 }
21744 arg2 = static_cast< bool >(val2);
21745 if (arg1) (arg1)->m_metaDown = arg2;
21746
21747 resultobj = SWIG_Py_Void();
21748 return resultobj;
21749 fail:
21750 return NULL;
21751 }
21752
21753
21754 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21755 PyObject *resultobj = 0;
21756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21757 bool result;
21758 void *argp1 = 0 ;
21759 int res1 = 0 ;
21760 PyObject *swig_obj[1] ;
21761
21762 if (!args) SWIG_fail;
21763 swig_obj[0] = args;
21764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21767 }
21768 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21769 result = (bool) ((arg1)->m_metaDown);
21770 {
21771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21772 }
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21782 int arg2 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 int val2 ;
21786 int ecode2 = 0 ;
21787 PyObject *swig_obj[2] ;
21788
21789 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21793 }
21794 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21795 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21796 if (!SWIG_IsOK(ecode2)) {
21797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21798 }
21799 arg2 = static_cast< int >(val2);
21800 if (arg1) (arg1)->m_wheelRotation = arg2;
21801
21802 resultobj = SWIG_Py_Void();
21803 return resultobj;
21804 fail:
21805 return NULL;
21806 }
21807
21808
21809 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21810 PyObject *resultobj = 0;
21811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21812 int result;
21813 void *argp1 = 0 ;
21814 int res1 = 0 ;
21815 PyObject *swig_obj[1] ;
21816
21817 if (!args) SWIG_fail;
21818 swig_obj[0] = args;
21819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21822 }
21823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21824 result = (int) ((arg1)->m_wheelRotation);
21825 resultobj = SWIG_From_int(static_cast< int >(result));
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21833 PyObject *resultobj = 0;
21834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21835 int arg2 ;
21836 void *argp1 = 0 ;
21837 int res1 = 0 ;
21838 int val2 ;
21839 int ecode2 = 0 ;
21840 PyObject *swig_obj[2] ;
21841
21842 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21846 }
21847 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21848 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21849 if (!SWIG_IsOK(ecode2)) {
21850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21851 }
21852 arg2 = static_cast< int >(val2);
21853 if (arg1) (arg1)->m_wheelDelta = arg2;
21854
21855 resultobj = SWIG_Py_Void();
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21865 int result;
21866 void *argp1 = 0 ;
21867 int res1 = 0 ;
21868 PyObject *swig_obj[1] ;
21869
21870 if (!args) SWIG_fail;
21871 swig_obj[0] = args;
21872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21873 if (!SWIG_IsOK(res1)) {
21874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21875 }
21876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21877 result = (int) ((arg1)->m_wheelDelta);
21878 resultobj = SWIG_From_int(static_cast< int >(result));
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21886 PyObject *resultobj = 0;
21887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21888 int arg2 ;
21889 void *argp1 = 0 ;
21890 int res1 = 0 ;
21891 int val2 ;
21892 int ecode2 = 0 ;
21893 PyObject *swig_obj[2] ;
21894
21895 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21899 }
21900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21901 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21902 if (!SWIG_IsOK(ecode2)) {
21903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21904 }
21905 arg2 = static_cast< int >(val2);
21906 if (arg1) (arg1)->m_linesPerAction = arg2;
21907
21908 resultobj = SWIG_Py_Void();
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 PyObject *resultobj = 0;
21917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21918 int result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 PyObject *swig_obj[1] ;
21922
21923 if (!args) SWIG_fail;
21924 swig_obj[0] = args;
21925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21928 }
21929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21930 result = (int) ((arg1)->m_linesPerAction);
21931 resultobj = SWIG_From_int(static_cast< int >(result));
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *obj;
21940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21941 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21942 return SWIG_Py_Void();
21943 }
21944
21945 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 return SWIG_Python_InitShadowInstance(args);
21947 }
21948
21949 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj = 0;
21951 int arg1 = (int) 0 ;
21952 int arg2 = (int) 0 ;
21953 wxSetCursorEvent *result = 0 ;
21954 int val1 ;
21955 int ecode1 = 0 ;
21956 int val2 ;
21957 int ecode2 = 0 ;
21958 PyObject * obj0 = 0 ;
21959 PyObject * obj1 = 0 ;
21960 char * kwnames[] = {
21961 (char *) "x",(char *) "y", NULL
21962 };
21963
21964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21965 if (obj0) {
21966 ecode1 = SWIG_AsVal_int(obj0, &val1);
21967 if (!SWIG_IsOK(ecode1)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21969 }
21970 arg1 = static_cast< int >(val1);
21971 }
21972 if (obj1) {
21973 ecode2 = SWIG_AsVal_int(obj1, &val2);
21974 if (!SWIG_IsOK(ecode2)) {
21975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21976 }
21977 arg2 = static_cast< int >(val2);
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21993 PyObject *resultobj = 0;
21994 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21995 int result;
21996 void *argp1 = 0 ;
21997 int res1 = 0 ;
21998 PyObject *swig_obj[1] ;
21999
22000 if (!args) SWIG_fail;
22001 swig_obj[0] = args;
22002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22003 if (!SWIG_IsOK(res1)) {
22004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22005 }
22006 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 resultobj = SWIG_From_int(static_cast< int >(result));
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22023 int result;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 PyObject *swig_obj[1] ;
22027
22028 if (!args) SWIG_fail;
22029 swig_obj[0] = args;
22030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22033 }
22034 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 resultobj = SWIG_From_int(static_cast< int >(result));
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj = 0;
22050 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22051 wxCursor *arg2 = 0 ;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 void *argp2 = 0 ;
22055 int res2 = 0 ;
22056 PyObject * obj0 = 0 ;
22057 PyObject * obj1 = 0 ;
22058 char * kwnames[] = {
22059 (char *) "self",(char *) "cursor", NULL
22060 };
22061
22062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22064 if (!SWIG_IsOK(res1)) {
22065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22066 }
22067 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22069 if (!SWIG_IsOK(res2)) {
22070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22071 }
22072 if (!argp2) {
22073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22074 }
22075 arg2 = reinterpret_cast< wxCursor * >(argp2);
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 (arg1)->SetCursor((wxCursor const &)*arg2);
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 resultobj = SWIG_Py_Void();
22083 return resultobj;
22084 fail:
22085 return NULL;
22086 }
22087
22088
22089 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22090 PyObject *resultobj = 0;
22091 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22092 wxCursor *result = 0 ;
22093 void *argp1 = 0 ;
22094 int res1 = 0 ;
22095 PyObject *swig_obj[1] ;
22096
22097 if (!args) SWIG_fail;
22098 swig_obj[0] = args;
22099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22100 if (!SWIG_IsOK(res1)) {
22101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22102 }
22103 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 {
22107 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22108 result = (wxCursor *) &_result_ref;
22109 }
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 {
22114 wxCursor* resultptr = new wxCursor(*result);
22115 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22116 }
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22126 bool result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22136 }
22137 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 {
22145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22146 }
22147 return resultobj;
22148 fail:
22149 return NULL;
22150 }
22151
22152
22153 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22154 PyObject *obj;
22155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22156 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22157 return SWIG_Py_Void();
22158 }
22159
22160 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 return SWIG_Python_InitShadowInstance(args);
22162 }
22163
22164 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj = 0;
22166 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22167 wxKeyEvent *result = 0 ;
22168 int val1 ;
22169 int ecode1 = 0 ;
22170 PyObject * obj0 = 0 ;
22171 char * kwnames[] = {
22172 (char *) "eventType", NULL
22173 };
22174
22175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22176 if (obj0) {
22177 ecode1 = SWIG_AsVal_int(obj0, &val1);
22178 if (!SWIG_IsOK(ecode1)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22180 }
22181 arg1 = static_cast< wxEventType >(val1);
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22199 int result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 PyObject *swig_obj[1] ;
22203
22204 if (!args) SWIG_fail;
22205 swig_obj[0] = args;
22206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22209 }
22210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_From_int(static_cast< int >(result));
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22225 PyObject *resultobj = 0;
22226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22227 bool result;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 PyObject *swig_obj[1] ;
22231
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22237 }
22238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22247 }
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22257 bool result;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22277 }
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22287 bool result;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 PyObject *swig_obj[1] ;
22291
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22297 }
22298 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 {
22306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22317 bool result;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 PyObject *swig_obj[1] ;
22321
22322 if (!args) SWIG_fail;
22323 swig_obj[0] = args;
22324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22325 if (!SWIG_IsOK(res1)) {
22326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22327 }
22328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22345 PyObject *resultobj = 0;
22346 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22347 bool result;
22348 void *argp1 = 0 ;
22349 int res1 = 0 ;
22350 PyObject *swig_obj[1] ;
22351
22352 if (!args) SWIG_fail;
22353 swig_obj[0] = args;
22354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22355 if (!SWIG_IsOK(res1)) {
22356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22357 }
22358 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 {
22366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22367 }
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22377 bool result;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 PyObject *swig_obj[1] ;
22381
22382 if (!args) SWIG_fail;
22383 swig_obj[0] = args;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 {
22396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22397 }
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 int result;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 PyObject *swig_obj[1] ;
22411
22412 if (!args) SWIG_fail;
22413 swig_obj[0] = args;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22417 }
22418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 resultobj = SWIG_From_int(static_cast< int >(result));
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int arg2 ;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 int val2 ;
22467 int ecode2 = 0 ;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char * kwnames[] = {
22471 (char *) "self",(char *) "uniChar", NULL
22472 };
22473
22474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22476 if (!SWIG_IsOK(res1)) {
22477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22478 }
22479 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22480 ecode2 = SWIG_AsVal_int(obj1, &val2);
22481 if (!SWIG_IsOK(ecode2)) {
22482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22483 }
22484 arg2 = static_cast< int >(val2);
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_Py_Void();
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 unsigned int result;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 PyObject *swig_obj[1] ;
22505
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 unsigned int result;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 PyObject *swig_obj[1] ;
22533
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22555 PyObject *resultobj = 0;
22556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22557 wxPoint result;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 PyObject *swig_obj[1] ;
22561
22562 if (!args) SWIG_fail;
22563 swig_obj[0] = args;
22564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 result = (arg1)->GetPosition();
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 long *arg2 = (long *) 0 ;
22586 long *arg3 = (long *) 0 ;
22587 void *argp1 = 0 ;
22588 int res1 = 0 ;
22589 long temp2 ;
22590 int res2 = SWIG_TMPOBJ ;
22591 long temp3 ;
22592 int res3 = SWIG_TMPOBJ ;
22593 PyObject *swig_obj[1] ;
22594
22595 arg2 = &temp2;
22596 arg3 = &temp3;
22597 if (!args) SWIG_fail;
22598 swig_obj[0] = args;
22599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22600 if (!SWIG_IsOK(res1)) {
22601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22602 }
22603 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 (arg1)->GetPosition(arg2,arg3);
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 resultobj = SWIG_Py_Void();
22611 if (SWIG_IsTmpObj(res2)) {
22612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22613 } else {
22614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22616 }
22617 if (SWIG_IsTmpObj(res3)) {
22618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22619 } else {
22620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22622 }
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 PyObject *resultobj = 0;
22631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22632 int result;
22633 void *argp1 = 0 ;
22634 int res1 = 0 ;
22635 PyObject *swig_obj[1] ;
22636
22637 if (!args) SWIG_fail;
22638 swig_obj[0] = args;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 result = (int)((wxKeyEvent const *)arg1)->GetX();
22647 wxPyEndAllowThreads(__tstate);
22648 if (PyErr_Occurred()) SWIG_fail;
22649 }
22650 resultobj = SWIG_From_int(static_cast< int >(result));
22651 return resultobj;
22652 fail:
22653 return NULL;
22654 }
22655
22656
22657 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22658 PyObject *resultobj = 0;
22659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22660 int result;
22661 void *argp1 = 0 ;
22662 int res1 = 0 ;
22663 PyObject *swig_obj[1] ;
22664
22665 if (!args) SWIG_fail;
22666 swig_obj[0] = args;
22667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22668 if (!SWIG_IsOK(res1)) {
22669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22670 }
22671 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 result = (int)((wxKeyEvent const *)arg1)->GetY();
22675 wxPyEndAllowThreads(__tstate);
22676 if (PyErr_Occurred()) SWIG_fail;
22677 }
22678 resultobj = SWIG_From_int(static_cast< int >(result));
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22686 PyObject *resultobj = 0;
22687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22688 int arg2 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 int val2 ;
22692 int ecode2 = 0 ;
22693 PyObject *swig_obj[2] ;
22694
22695 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22699 }
22700 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22701 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22702 if (!SWIG_IsOK(ecode2)) {
22703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22704 }
22705 arg2 = static_cast< int >(val2);
22706 if (arg1) (arg1)->m_x = arg2;
22707
22708 resultobj = SWIG_Py_Void();
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 int result;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 PyObject *swig_obj[1] ;
22722
22723 if (!args) SWIG_fail;
22724 swig_obj[0] = args;
22725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22730 result = (int) ((arg1)->m_x);
22731 resultobj = SWIG_From_int(static_cast< int >(result));
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22739 PyObject *resultobj = 0;
22740 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22741 int arg2 ;
22742 void *argp1 = 0 ;
22743 int res1 = 0 ;
22744 int val2 ;
22745 int ecode2 = 0 ;
22746 PyObject *swig_obj[2] ;
22747
22748 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22750 if (!SWIG_IsOK(res1)) {
22751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22752 }
22753 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22754 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22755 if (!SWIG_IsOK(ecode2)) {
22756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22757 }
22758 arg2 = static_cast< int >(val2);
22759 if (arg1) (arg1)->m_y = arg2;
22760
22761 resultobj = SWIG_Py_Void();
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22771 int result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22781 }
22782 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22783 result = (int) ((arg1)->m_y);
22784 resultobj = SWIG_From_int(static_cast< int >(result));
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22794 long arg2 ;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 long val2 ;
22798 int ecode2 = 0 ;
22799 PyObject *swig_obj[2] ;
22800
22801 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22805 }
22806 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22807 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22808 if (!SWIG_IsOK(ecode2)) {
22809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22810 }
22811 arg2 = static_cast< long >(val2);
22812 if (arg1) (arg1)->m_keyCode = arg2;
22813
22814 resultobj = SWIG_Py_Void();
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22824 long result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22834 }
22835 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22836 result = (long) ((arg1)->m_keyCode);
22837 resultobj = SWIG_From_long(static_cast< long >(result));
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22847 bool arg2 ;
22848 void *argp1 = 0 ;
22849 int res1 = 0 ;
22850 bool val2 ;
22851 int ecode2 = 0 ;
22852 PyObject *swig_obj[2] ;
22853
22854 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22861 if (!SWIG_IsOK(ecode2)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22863 }
22864 arg2 = static_cast< bool >(val2);
22865 if (arg1) (arg1)->m_controlDown = arg2;
22866
22867 resultobj = SWIG_Py_Void();
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22875 PyObject *resultobj = 0;
22876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22877 bool result;
22878 void *argp1 = 0 ;
22879 int res1 = 0 ;
22880 PyObject *swig_obj[1] ;
22881
22882 if (!args) SWIG_fail;
22883 swig_obj[0] = args;
22884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22887 }
22888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22889 result = (bool) ((arg1)->m_controlDown);
22890 {
22891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22892 }
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22900 PyObject *resultobj = 0;
22901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22902 bool arg2 ;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 bool val2 ;
22906 int ecode2 = 0 ;
22907 PyObject *swig_obj[2] ;
22908
22909 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22913 }
22914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22915 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22916 if (!SWIG_IsOK(ecode2)) {
22917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22918 }
22919 arg2 = static_cast< bool >(val2);
22920 if (arg1) (arg1)->m_shiftDown = arg2;
22921
22922 resultobj = SWIG_Py_Void();
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 PyObject *resultobj = 0;
22931 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22932 bool result;
22933 void *argp1 = 0 ;
22934 int res1 = 0 ;
22935 PyObject *swig_obj[1] ;
22936
22937 if (!args) SWIG_fail;
22938 swig_obj[0] = args;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22942 }
22943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22944 result = (bool) ((arg1)->m_shiftDown);
22945 {
22946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22957 bool arg2 ;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 bool val2 ;
22961 int ecode2 = 0 ;
22962 PyObject *swig_obj[2] ;
22963
22964 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22966 if (!SWIG_IsOK(res1)) {
22967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22968 }
22969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22970 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22971 if (!SWIG_IsOK(ecode2)) {
22972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22973 }
22974 arg2 = static_cast< bool >(val2);
22975 if (arg1) (arg1)->m_altDown = arg2;
22976
22977 resultobj = SWIG_Py_Void();
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 PyObject *resultobj = 0;
22986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22987 bool result;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 PyObject *swig_obj[1] ;
22991
22992 if (!args) SWIG_fail;
22993 swig_obj[0] = args;
22994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22997 }
22998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22999 result = (bool) ((arg1)->m_altDown);
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23012 bool arg2 ;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 bool val2 ;
23016 int ecode2 = 0 ;
23017 PyObject *swig_obj[2] ;
23018
23019 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23021 if (!SWIG_IsOK(res1)) {
23022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23023 }
23024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23025 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23026 if (!SWIG_IsOK(ecode2)) {
23027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23028 }
23029 arg2 = static_cast< bool >(val2);
23030 if (arg1) (arg1)->m_metaDown = arg2;
23031
23032 resultobj = SWIG_Py_Void();
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23042 bool result;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 PyObject *swig_obj[1] ;
23046
23047 if (!args) SWIG_fail;
23048 swig_obj[0] = args;
23049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23054 result = (bool) ((arg1)->m_metaDown);
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23067 bool arg2 ;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 bool val2 ;
23071 int ecode2 = 0 ;
23072 PyObject *swig_obj[2] ;
23073
23074 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23080 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23083 }
23084 arg2 = static_cast< bool >(val2);
23085 if (arg1) (arg1)->m_scanCode = arg2;
23086
23087 resultobj = SWIG_Py_Void();
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23097 bool result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23109 result = (bool) ((arg1)->m_scanCode);
23110 {
23111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23112 }
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23120 PyObject *resultobj = 0;
23121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23122 unsigned int arg2 ;
23123 void *argp1 = 0 ;
23124 int res1 = 0 ;
23125 unsigned int val2 ;
23126 int ecode2 = 0 ;
23127 PyObject *swig_obj[2] ;
23128
23129 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23131 if (!SWIG_IsOK(res1)) {
23132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23133 }
23134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23135 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23136 if (!SWIG_IsOK(ecode2)) {
23137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23138 }
23139 arg2 = static_cast< unsigned int >(val2);
23140 if (arg1) (arg1)->m_rawCode = arg2;
23141
23142 resultobj = SWIG_Py_Void();
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150 PyObject *resultobj = 0;
23151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23152 unsigned int result;
23153 void *argp1 = 0 ;
23154 int res1 = 0 ;
23155 PyObject *swig_obj[1] ;
23156
23157 if (!args) SWIG_fail;
23158 swig_obj[0] = args;
23159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23160 if (!SWIG_IsOK(res1)) {
23161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23162 }
23163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23164 result = (unsigned int) ((arg1)->m_rawCode);
23165 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23173 PyObject *resultobj = 0;
23174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23175 unsigned int arg2 ;
23176 void *argp1 = 0 ;
23177 int res1 = 0 ;
23178 unsigned int val2 ;
23179 int ecode2 = 0 ;
23180 PyObject *swig_obj[2] ;
23181
23182 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23186 }
23187 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23188 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23189 if (!SWIG_IsOK(ecode2)) {
23190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23191 }
23192 arg2 = static_cast< unsigned int >(val2);
23193 if (arg1) (arg1)->m_rawFlags = arg2;
23194
23195 resultobj = SWIG_Py_Void();
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23205 unsigned int result;
23206 void *argp1 = 0 ;
23207 int res1 = 0 ;
23208 PyObject *swig_obj[1] ;
23209
23210 if (!args) SWIG_fail;
23211 swig_obj[0] = args;
23212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23213 if (!SWIG_IsOK(res1)) {
23214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23215 }
23216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23217 result = (unsigned int) ((arg1)->m_rawFlags);
23218 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23226 PyObject *obj;
23227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23228 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23229 return SWIG_Py_Void();
23230 }
23231
23232 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23233 return SWIG_Python_InitShadowInstance(args);
23234 }
23235
23236 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23237 PyObject *resultobj = 0;
23238 wxSize const &arg1_defvalue = wxDefaultSize ;
23239 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23240 int arg2 = (int) 0 ;
23241 wxSizeEvent *result = 0 ;
23242 wxSize temp1 ;
23243 int val2 ;
23244 int ecode2 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 PyObject * obj1 = 0 ;
23247 char * kwnames[] = {
23248 (char *) "sz",(char *) "winid", NULL
23249 };
23250
23251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23252 if (obj0) {
23253 {
23254 arg1 = &temp1;
23255 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23256 }
23257 }
23258 if (obj1) {
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23262 }
23263 arg2 = static_cast< int >(val2);
23264 }
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 PyObject *resultobj = 0;
23280 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23281 wxSize result;
23282 void *argp1 = 0 ;
23283 int res1 = 0 ;
23284 PyObject *swig_obj[1] ;
23285
23286 if (!args) SWIG_fail;
23287 swig_obj[0] = args;
23288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23289 if (!SWIG_IsOK(res1)) {
23290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23291 }
23292 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23293 {
23294 PyThreadState* __tstate = wxPyBeginAllowThreads();
23295 result = ((wxSizeEvent const *)arg1)->GetSize();
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 PyObject *resultobj = 0;
23308 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23309 wxRect result;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 PyObject *swig_obj[1] ;
23313
23314 if (!args) SWIG_fail;
23315 swig_obj[0] = args;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23319 }
23320 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = ((wxSizeEvent const *)arg1)->GetRect();
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj = 0;
23336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23337 wxRect arg2 ;
23338 void *argp1 = 0 ;
23339 int res1 = 0 ;
23340 void *argp2 ;
23341 int res2 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 PyObject * obj1 = 0 ;
23344 char * kwnames[] = {
23345 (char *) "self",(char *) "rect", NULL
23346 };
23347
23348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23350 if (!SWIG_IsOK(res1)) {
23351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23352 }
23353 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23354 {
23355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23356 if (!SWIG_IsOK(res2)) {
23357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23358 }
23359 if (!argp2) {
23360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23361 } else {
23362 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23363 arg2 = *temp;
23364 if (SWIG_IsNewObj(res2)) delete temp;
23365 }
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 (arg1)->SetRect(arg2);
23370 wxPyEndAllowThreads(__tstate);
23371 if (PyErr_Occurred()) SWIG_fail;
23372 }
23373 resultobj = SWIG_Py_Void();
23374 return resultobj;
23375 fail:
23376 return NULL;
23377 }
23378
23379
23380 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23381 PyObject *resultobj = 0;
23382 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23383 wxSize arg2 ;
23384 void *argp1 = 0 ;
23385 int res1 = 0 ;
23386 void *argp2 ;
23387 int res2 = 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "self",(char *) "size", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23400 {
23401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23402 if (!SWIG_IsOK(res2)) {
23403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23404 }
23405 if (!argp2) {
23406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23407 } else {
23408 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23409 arg2 = *temp;
23410 if (SWIG_IsNewObj(res2)) delete temp;
23411 }
23412 }
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 wxSizeEvent_SetSize(arg1,arg2);
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_Py_Void();
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23429 wxSize *arg2 = (wxSize *) 0 ;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 void *argp2 = 0 ;
23433 int res2 = 0 ;
23434 PyObject *swig_obj[2] ;
23435
23436 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23440 }
23441 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23443 if (!SWIG_IsOK(res2)) {
23444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23445 }
23446 arg2 = reinterpret_cast< wxSize * >(argp2);
23447 if (arg1) (arg1)->m_size = *arg2;
23448
23449 resultobj = SWIG_Py_Void();
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23459 wxSize *result = 0 ;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23471 result = (wxSize *)& ((arg1)->m_size);
23472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23480 PyObject *resultobj = 0;
23481 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23482 wxRect *arg2 = (wxRect *) 0 ;
23483 void *argp1 = 0 ;
23484 int res1 = 0 ;
23485 void *argp2 = 0 ;
23486 int res2 = 0 ;
23487 PyObject *swig_obj[2] ;
23488
23489 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23493 }
23494 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23496 if (!SWIG_IsOK(res2)) {
23497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23498 }
23499 arg2 = reinterpret_cast< wxRect * >(argp2);
23500 if (arg1) (arg1)->m_rect = *arg2;
23501
23502 resultobj = SWIG_Py_Void();
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 PyObject *resultobj = 0;
23511 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23512 wxRect *result = 0 ;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 PyObject *swig_obj[1] ;
23516
23517 if (!args) SWIG_fail;
23518 swig_obj[0] = args;
23519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23520 if (!SWIG_IsOK(res1)) {
23521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23522 }
23523 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23524 result = (wxRect *)& ((arg1)->m_rect);
23525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23533 PyObject *obj;
23534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23535 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23536 return SWIG_Py_Void();
23537 }
23538
23539 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 return SWIG_Python_InitShadowInstance(args);
23541 }
23542
23543 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj = 0;
23545 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23546 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23547 int arg2 = (int) 0 ;
23548 wxMoveEvent *result = 0 ;
23549 wxPoint temp1 ;
23550 int val2 ;
23551 int ecode2 = 0 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char * kwnames[] = {
23555 (char *) "pos",(char *) "winid", NULL
23556 };
23557
23558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23559 if (obj0) {
23560 {
23561 arg1 = &temp1;
23562 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23563 }
23564 }
23565 if (obj1) {
23566 ecode2 = SWIG_AsVal_int(obj1, &val2);
23567 if (!SWIG_IsOK(ecode2)) {
23568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23569 }
23570 arg2 = static_cast< int >(val2);
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23586 PyObject *resultobj = 0;
23587 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23588 wxPoint result;
23589 void *argp1 = 0 ;
23590 int res1 = 0 ;
23591 PyObject *swig_obj[1] ;
23592
23593 if (!args) SWIG_fail;
23594 swig_obj[0] = args;
23595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23596 if (!SWIG_IsOK(res1)) {
23597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23598 }
23599 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23600 {
23601 PyThreadState* __tstate = wxPyBeginAllowThreads();
23602 result = ((wxMoveEvent const *)arg1)->GetPosition();
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23616 wxRect result;
23617 void *argp1 = 0 ;
23618 int res1 = 0 ;
23619 PyObject *swig_obj[1] ;
23620
23621 if (!args) SWIG_fail;
23622 swig_obj[0] = args;
23623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23624 if (!SWIG_IsOK(res1)) {
23625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23626 }
23627 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = ((wxMoveEvent const *)arg1)->GetRect();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23644 wxRect *arg2 = 0 ;
23645 void *argp1 = 0 ;
23646 int res1 = 0 ;
23647 wxRect temp2 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 char * kwnames[] = {
23651 (char *) "self",(char *) "rect", NULL
23652 };
23653
23654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23658 }
23659 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23660 {
23661 arg2 = &temp2;
23662 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 (arg1)->SetRect((wxRect const &)*arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_Py_Void();
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23680 wxPoint *arg2 = 0 ;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 wxPoint temp2 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 char * kwnames[] = {
23687 (char *) "self",(char *) "pos", NULL
23688 };
23689
23690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23692 if (!SWIG_IsOK(res1)) {
23693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23694 }
23695 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23696 {
23697 arg2 = &temp2;
23698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23699 }
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 (arg1)->SetPosition((wxPoint const &)*arg2);
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 resultobj = SWIG_Py_Void();
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *obj;
23715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23716 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23717 return SWIG_Py_Void();
23718 }
23719
23720 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 return SWIG_Python_InitShadowInstance(args);
23722 }
23723
23724 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 int arg1 = (int) 0 ;
23727 wxPaintEvent *result = 0 ;
23728 int val1 ;
23729 int ecode1 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 char * kwnames[] = {
23732 (char *) "Id", NULL
23733 };
23734
23735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23736 if (obj0) {
23737 ecode1 = SWIG_AsVal_int(obj0, &val1);
23738 if (!SWIG_IsOK(ecode1)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23740 }
23741 arg1 = static_cast< int >(val1);
23742 }
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23750 return resultobj;
23751 fail:
23752 return NULL;
23753 }
23754
23755
23756 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757 PyObject *obj;
23758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23759 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23760 return SWIG_Py_Void();
23761 }
23762
23763 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 return SWIG_Python_InitShadowInstance(args);
23765 }
23766
23767 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 int arg1 = (int) 0 ;
23770 wxNcPaintEvent *result = 0 ;
23771 int val1 ;
23772 int ecode1 = 0 ;
23773 PyObject * obj0 = 0 ;
23774 char * kwnames[] = {
23775 (char *) "winid", NULL
23776 };
23777
23778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23779 if (obj0) {
23780 ecode1 = SWIG_AsVal_int(obj0, &val1);
23781 if (!SWIG_IsOK(ecode1)) {
23782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23783 }
23784 arg1 = static_cast< int >(val1);
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *obj;
23801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23802 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23803 return SWIG_Py_Void();
23804 }
23805
23806 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23807 return SWIG_Python_InitShadowInstance(args);
23808 }
23809
23810 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj = 0;
23812 int arg1 = (int) 0 ;
23813 wxDC *arg2 = (wxDC *) NULL ;
23814 wxEraseEvent *result = 0 ;
23815 int val1 ;
23816 int ecode1 = 0 ;
23817 void *argp2 = 0 ;
23818 int res2 = 0 ;
23819 PyObject * obj0 = 0 ;
23820 PyObject * obj1 = 0 ;
23821 char * kwnames[] = {
23822 (char *) "Id",(char *) "dc", NULL
23823 };
23824
23825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23826 if (obj0) {
23827 ecode1 = SWIG_AsVal_int(obj0, &val1);
23828 if (!SWIG_IsOK(ecode1)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23830 }
23831 arg1 = static_cast< int >(val1);
23832 }
23833 if (obj1) {
23834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23835 if (!SWIG_IsOK(res2)) {
23836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23837 }
23838 arg2 = reinterpret_cast< wxDC * >(argp2);
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23854 PyObject *resultobj = 0;
23855 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23856 wxDC *result = 0 ;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 PyObject *swig_obj[1] ;
23860
23861 if (!args) SWIG_fail;
23862 swig_obj[0] = args;
23863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23864 if (!SWIG_IsOK(res1)) {
23865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23866 }
23867 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 {
23875 resultobj = wxPyMake_wxObject(result, (bool)0);
23876 }
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *obj;
23885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23886 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23887 return SWIG_Py_Void();
23888 }
23889
23890 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23891 return SWIG_Python_InitShadowInstance(args);
23892 }
23893
23894 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23897 int arg2 = (int) 0 ;
23898 wxFocusEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 int val2 ;
23902 int ecode2 = 0 ;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905 char * kwnames[] = {
23906 (char *) "type",(char *) "winid", NULL
23907 };
23908
23909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23910 if (obj0) {
23911 ecode1 = SWIG_AsVal_int(obj0, &val1);
23912 if (!SWIG_IsOK(ecode1)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23914 }
23915 arg1 = static_cast< wxEventType >(val1);
23916 }
23917 if (obj1) {
23918 ecode2 = SWIG_AsVal_int(obj1, &val2);
23919 if (!SWIG_IsOK(ecode2)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23921 }
23922 arg2 = static_cast< int >(val2);
23923 }
23924 {
23925 PyThreadState* __tstate = wxPyBeginAllowThreads();
23926 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23938 PyObject *resultobj = 0;
23939 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23940 wxWindow *result = 0 ;
23941 void *argp1 = 0 ;
23942 int res1 = 0 ;
23943 PyObject *swig_obj[1] ;
23944
23945 if (!args) SWIG_fail;
23946 swig_obj[0] = args;
23947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23950 }
23951 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = wxPyMake_wxObject(result, (bool)0);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23970 wxWindow *arg2 = (wxWindow *) 0 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 void *argp2 = 0 ;
23974 int res2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "self",(char *) "win", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23985 }
23986 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23988 if (!SWIG_IsOK(res2)) {
23989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23990 }
23991 arg2 = reinterpret_cast< wxWindow * >(argp2);
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 (arg1)->SetWindow(arg2);
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 resultobj = SWIG_Py_Void();
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *obj;
24007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24008 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24009 return SWIG_Py_Void();
24010 }
24011
24012 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 return SWIG_Python_InitShadowInstance(args);
24014 }
24015
24016 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxWindow *arg1 = (wxWindow *) NULL ;
24019 wxChildFocusEvent *result = 0 ;
24020 void *argp1 = 0 ;
24021 int res1 = 0 ;
24022 PyObject * obj0 = 0 ;
24023 char * kwnames[] = {
24024 (char *) "win", NULL
24025 };
24026
24027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24028 if (obj0) {
24029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24032 }
24033 arg1 = reinterpret_cast< wxWindow * >(argp1);
24034 }
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24049 PyObject *resultobj = 0;
24050 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24051 wxWindow *result = 0 ;
24052 void *argp1 = 0 ;
24053 int res1 = 0 ;
24054 PyObject *swig_obj[1] ;
24055
24056 if (!args) SWIG_fail;
24057 swig_obj[0] = args;
24058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24059 if (!SWIG_IsOK(res1)) {
24060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24061 }
24062 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 {
24070 resultobj = wxPyMake_wxObject(result, (bool)0);
24071 }
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24079 PyObject *obj;
24080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24081 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24082 return SWIG_Py_Void();
24083 }
24084
24085 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 return SWIG_Python_InitShadowInstance(args);
24087 }
24088
24089 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj = 0;
24091 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24092 bool arg2 = (bool) true ;
24093 int arg3 = (int) 0 ;
24094 wxActivateEvent *result = 0 ;
24095 int val1 ;
24096 int ecode1 = 0 ;
24097 bool val2 ;
24098 int ecode2 = 0 ;
24099 int val3 ;
24100 int ecode3 = 0 ;
24101 PyObject * obj0 = 0 ;
24102 PyObject * obj1 = 0 ;
24103 PyObject * obj2 = 0 ;
24104 char * kwnames[] = {
24105 (char *) "type",(char *) "active",(char *) "Id", NULL
24106 };
24107
24108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24109 if (obj0) {
24110 ecode1 = SWIG_AsVal_int(obj0, &val1);
24111 if (!SWIG_IsOK(ecode1)) {
24112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24113 }
24114 arg1 = static_cast< wxEventType >(val1);
24115 }
24116 if (obj1) {
24117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24118 if (!SWIG_IsOK(ecode2)) {
24119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24120 }
24121 arg2 = static_cast< bool >(val2);
24122 }
24123 if (obj2) {
24124 ecode3 = SWIG_AsVal_int(obj2, &val3);
24125 if (!SWIG_IsOK(ecode3)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24127 }
24128 arg3 = static_cast< int >(val3);
24129 }
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24146 bool result;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject *swig_obj[1] ;
24150
24151 if (!args) SWIG_fail;
24152 swig_obj[0] = args;
24153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *obj;
24175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24176 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24177 return SWIG_Py_Void();
24178 }
24179
24180 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 return SWIG_Python_InitShadowInstance(args);
24182 }
24183
24184 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj = 0;
24186 int arg1 = (int) 0 ;
24187 wxInitDialogEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 PyObject * obj0 = 0 ;
24191 char * kwnames[] = {
24192 (char *) "Id", NULL
24193 };
24194
24195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24196 if (obj0) {
24197 ecode1 = SWIG_AsVal_int(obj0, &val1);
24198 if (!SWIG_IsOK(ecode1)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24200 }
24201 arg1 = static_cast< int >(val1);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *obj;
24218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24219 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24220 return SWIG_Py_Void();
24221 }
24222
24223 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 return SWIG_Python_InitShadowInstance(args);
24225 }
24226
24227 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24230 int arg2 = (int) 0 ;
24231 wxMenu *arg3 = (wxMenu *) NULL ;
24232 wxMenuEvent *result = 0 ;
24233 int val1 ;
24234 int ecode1 = 0 ;
24235 int val2 ;
24236 int ecode2 = 0 ;
24237 void *argp3 = 0 ;
24238 int res3 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 PyObject * obj2 = 0 ;
24242 char * kwnames[] = {
24243 (char *) "type",(char *) "winid",(char *) "menu", NULL
24244 };
24245
24246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24247 if (obj0) {
24248 ecode1 = SWIG_AsVal_int(obj0, &val1);
24249 if (!SWIG_IsOK(ecode1)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24251 }
24252 arg1 = static_cast< wxEventType >(val1);
24253 }
24254 if (obj1) {
24255 ecode2 = SWIG_AsVal_int(obj1, &val2);
24256 if (!SWIG_IsOK(ecode2)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24258 }
24259 arg2 = static_cast< int >(val2);
24260 }
24261 if (obj2) {
24262 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24263 if (!SWIG_IsOK(res3)) {
24264 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24265 }
24266 arg3 = reinterpret_cast< wxMenu * >(argp3);
24267 }
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24284 int result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 resultobj = SWIG_From_int(static_cast< int >(result));
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24312 bool result;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24342 wxMenu *result = 0 ;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24352 }
24353 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = wxPyMake_wxObject(result, (bool)0);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24370 PyObject *obj;
24371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24372 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24373 return SWIG_Py_Void();
24374 }
24375
24376 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 return SWIG_Python_InitShadowInstance(args);
24378 }
24379
24380 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24383 int arg2 = (int) 0 ;
24384 wxCloseEvent *result = 0 ;
24385 int val1 ;
24386 int ecode1 = 0 ;
24387 int val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "type",(char *) "winid", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24396 if (obj0) {
24397 ecode1 = SWIG_AsVal_int(obj0, &val1);
24398 if (!SWIG_IsOK(ecode1)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24400 }
24401 arg1 = static_cast< wxEventType >(val1);
24402 }
24403 if (obj1) {
24404 ecode2 = SWIG_AsVal_int(obj1, &val2);
24405 if (!SWIG_IsOK(ecode2)) {
24406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24407 }
24408 arg2 = static_cast< int >(val2);
24409 }
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24426 bool arg2 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 bool val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "logOff", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24446 }
24447 arg2 = static_cast< bool >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetLoggingOff(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24464 bool result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj = 0;
24493 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24494 bool arg2 = (bool) true ;
24495 void *argp1 = 0 ;
24496 int res1 = 0 ;
24497 bool val2 ;
24498 int ecode2 = 0 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 char * kwnames[] = {
24502 (char *) "self",(char *) "veto", NULL
24503 };
24504
24505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24507 if (!SWIG_IsOK(res1)) {
24508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24509 }
24510 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24511 if (obj1) {
24512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24513 if (!SWIG_IsOK(ecode2)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24515 }
24516 arg2 = static_cast< bool >(val2);
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 (arg1)->Veto(arg2);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_Py_Void();
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *resultobj = 0;
24533 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24534 bool result;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 PyObject *swig_obj[1] ;
24538
24539 if (!args) SWIG_fail;
24540 swig_obj[0] = args;
24541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24544 }
24545 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 {
24553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24554 }
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj = 0;
24563 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24564 bool arg2 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 bool val2 ;
24568 int ecode2 = 0 ;
24569 PyObject * obj0 = 0 ;
24570 PyObject * obj1 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "canVeto", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24579 }
24580 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24584 }
24585 arg2 = static_cast< bool >(val2);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 (arg1)->SetCanVeto(arg2);
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_Py_Void();
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24602 bool result;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24612 }
24613 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 {
24621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24622 }
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 int arg1 = (int) 0 ;
24643 bool arg2 = (bool) false ;
24644 wxShowEvent *result = 0 ;
24645 int val1 ;
24646 int ecode1 = 0 ;
24647 bool val2 ;
24648 int ecode2 = 0 ;
24649 PyObject * obj0 = 0 ;
24650 PyObject * obj1 = 0 ;
24651 char * kwnames[] = {
24652 (char *) "winid",(char *) "show", NULL
24653 };
24654
24655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24656 if (obj0) {
24657 ecode1 = SWIG_AsVal_int(obj0, &val1);
24658 if (!SWIG_IsOK(ecode1)) {
24659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24660 }
24661 arg1 = static_cast< int >(val1);
24662 }
24663 if (obj1) {
24664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24665 if (!SWIG_IsOK(ecode2)) {
24666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24667 }
24668 arg2 = static_cast< bool >(val2);
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj = 0;
24685 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24686 bool arg2 ;
24687 void *argp1 = 0 ;
24688 int res1 = 0 ;
24689 bool val2 ;
24690 int ecode2 = 0 ;
24691 PyObject * obj0 = 0 ;
24692 PyObject * obj1 = 0 ;
24693 char * kwnames[] = {
24694 (char *) "self",(char *) "show", NULL
24695 };
24696
24697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24699 if (!SWIG_IsOK(res1)) {
24700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24701 }
24702 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24704 if (!SWIG_IsOK(ecode2)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24706 }
24707 arg2 = static_cast< bool >(val2);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 (arg1)->SetShow(arg2);
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_Py_Void();
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24722 PyObject *resultobj = 0;
24723 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24724 bool result;
24725 void *argp1 = 0 ;
24726 int res1 = 0 ;
24727 PyObject *swig_obj[1] ;
24728
24729 if (!args) SWIG_fail;
24730 swig_obj[0] = args;
24731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24732 if (!SWIG_IsOK(res1)) {
24733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24734 }
24735 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 PyObject *obj;
24753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24754 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24755 return SWIG_Py_Void();
24756 }
24757
24758 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24759 return SWIG_Python_InitShadowInstance(args);
24760 }
24761
24762 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj = 0;
24764 int arg1 = (int) 0 ;
24765 bool arg2 = (bool) true ;
24766 wxIconizeEvent *result = 0 ;
24767 int val1 ;
24768 int ecode1 = 0 ;
24769 bool val2 ;
24770 int ecode2 = 0 ;
24771 PyObject * obj0 = 0 ;
24772 PyObject * obj1 = 0 ;
24773 char * kwnames[] = {
24774 (char *) "id",(char *) "iconized", NULL
24775 };
24776
24777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24778 if (obj0) {
24779 ecode1 = SWIG_AsVal_int(obj0, &val1);
24780 if (!SWIG_IsOK(ecode1)) {
24781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24782 }
24783 arg1 = static_cast< int >(val1);
24784 }
24785 if (obj1) {
24786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24787 if (!SWIG_IsOK(ecode2)) {
24788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24789 }
24790 arg2 = static_cast< bool >(val2);
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 PyObject *resultobj = 0;
24807 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24808 bool result;
24809 void *argp1 = 0 ;
24810 int res1 = 0 ;
24811 PyObject *swig_obj[1] ;
24812
24813 if (!args) SWIG_fail;
24814 swig_obj[0] = args;
24815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24816 if (!SWIG_IsOK(res1)) {
24817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24818 }
24819 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 result = (bool)(arg1)->Iconized();
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 {
24827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24828 }
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24836 PyObject *obj;
24837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24838 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24839 return SWIG_Py_Void();
24840 }
24841
24842 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 return SWIG_Python_InitShadowInstance(args);
24844 }
24845
24846 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24847 PyObject *resultobj = 0;
24848 int arg1 = (int) 0 ;
24849 wxMaximizeEvent *result = 0 ;
24850 int val1 ;
24851 int ecode1 = 0 ;
24852 PyObject * obj0 = 0 ;
24853 char * kwnames[] = {
24854 (char *) "id", NULL
24855 };
24856
24857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24858 if (obj0) {
24859 ecode1 = SWIG_AsVal_int(obj0, &val1);
24860 if (!SWIG_IsOK(ecode1)) {
24861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24862 }
24863 arg1 = static_cast< int >(val1);
24864 }
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *obj;
24880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24881 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24882 return SWIG_Py_Void();
24883 }
24884
24885 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 return SWIG_Python_InitShadowInstance(args);
24887 }
24888
24889 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24892 wxPoint result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24902 }
24903 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (arg1)->GetPosition();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24920 int result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (int)(arg1)->GetNumberOfFiles();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_From_int(static_cast< int >(result));
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24948 PyObject *result = 0 ;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24958 }
24959 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = result;
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *obj;
24975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24976 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24977 return SWIG_Py_Void();
24978 }
24979
24980 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24981 PyObject *resultobj = 0;
24982 int arg1 = (int) 0 ;
24983 wxUpdateUIEvent *result = 0 ;
24984 int val1 ;
24985 int ecode1 = 0 ;
24986 PyObject * obj0 = 0 ;
24987 char * kwnames[] = {
24988 (char *) "commandId", NULL
24989 };
24990
24991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24992 if (obj0) {
24993 ecode1 = SWIG_AsVal_int(obj0, &val1);
24994 if (!SWIG_IsOK(ecode1)) {
24995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24996 }
24997 arg1 = static_cast< int >(val1);
24998 }
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25013 PyObject *resultobj = 0;
25014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25015 bool result;
25016 void *argp1 = 0 ;
25017 int res1 = 0 ;
25018 PyObject *swig_obj[1] ;
25019
25020 if (!args) SWIG_fail;
25021 swig_obj[0] = args;
25022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25025 }
25026 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25035 }
25036 return resultobj;
25037 fail:
25038 return NULL;
25039 }
25040
25041
25042 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25043 PyObject *resultobj = 0;
25044 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25045 bool result;
25046 void *argp1 = 0 ;
25047 int res1 = 0 ;
25048 PyObject *swig_obj[1] ;
25049
25050 if (!args) SWIG_fail;
25051 swig_obj[0] = args;
25052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25053 if (!SWIG_IsOK(res1)) {
25054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25055 }
25056 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 {
25064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25065 }
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25073 PyObject *resultobj = 0;
25074 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25075 bool result;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 PyObject *swig_obj[1] ;
25079
25080 if (!args) SWIG_fail;
25081 swig_obj[0] = args;
25082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25083 if (!SWIG_IsOK(res1)) {
25084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25085 }
25086 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 {
25094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25095 }
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25103 PyObject *resultobj = 0;
25104 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25105 wxString 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_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 #if wxUSE_UNICODE
25125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25126 #else
25127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25128 #endif
25129 }
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25137 PyObject *resultobj = 0;
25138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25139 bool result;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 PyObject *swig_obj[1] ;
25143
25144 if (!args) SWIG_fail;
25145 swig_obj[0] = args;
25146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25149 }
25150 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25167 PyObject *resultobj = 0;
25168 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25169 bool result;
25170 void *argp1 = 0 ;
25171 int res1 = 0 ;
25172 PyObject *swig_obj[1] ;
25173
25174 if (!args) SWIG_fail;
25175 swig_obj[0] = args;
25176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25199 bool result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 PyObject *swig_obj[1] ;
25203
25204 if (!args) SWIG_fail;
25205 swig_obj[0] = args;
25206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25209 }
25210 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25227 PyObject *resultobj = 0;
25228 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25229 bool result;
25230 void *argp1 = 0 ;
25231 int res1 = 0 ;
25232 PyObject *swig_obj[1] ;
25233
25234 if (!args) SWIG_fail;
25235 swig_obj[0] = args;
25236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25237 if (!SWIG_IsOK(res1)) {
25238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25239 }
25240 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 {
25248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = 0;
25258 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25259 bool arg2 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 bool val2 ;
25263 int ecode2 = 0 ;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "check", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25274 }
25275 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25279 }
25280 arg2 = static_cast< bool >(val2);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 (arg1)->Check(arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_Py_Void();
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj = 0;
25296 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25297 bool arg2 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 bool val2 ;
25301 int ecode2 = 0 ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "self",(char *) "enable", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25310 if (!SWIG_IsOK(res1)) {
25311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25312 }
25313 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25315 if (!SWIG_IsOK(ecode2)) {
25316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25317 }
25318 arg2 = static_cast< bool >(val2);
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 (arg1)->Enable(arg2);
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_Py_Void();
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj = 0;
25334 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25335 bool arg2 ;
25336 void *argp1 = 0 ;
25337 int res1 = 0 ;
25338 bool val2 ;
25339 int ecode2 = 0 ;
25340 PyObject * obj0 = 0 ;
25341 PyObject * obj1 = 0 ;
25342 char * kwnames[] = {
25343 (char *) "self",(char *) "show", NULL
25344 };
25345
25346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25348 if (!SWIG_IsOK(res1)) {
25349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25350 }
25351 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25353 if (!SWIG_IsOK(ecode2)) {
25354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25355 }
25356 arg2 = static_cast< bool >(val2);
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 (arg1)->Show(arg2);
25360 wxPyEndAllowThreads(__tstate);
25361 if (PyErr_Occurred()) SWIG_fail;
25362 }
25363 resultobj = SWIG_Py_Void();
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = 0;
25372 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25373 wxString *arg2 = 0 ;
25374 void *argp1 = 0 ;
25375 int res1 = 0 ;
25376 bool temp2 = false ;
25377 PyObject * obj0 = 0 ;
25378 PyObject * obj1 = 0 ;
25379 char * kwnames[] = {
25380 (char *) "self",(char *) "text", NULL
25381 };
25382
25383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25387 }
25388 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25389 {
25390 arg2 = wxString_in_helper(obj1);
25391 if (arg2 == NULL) SWIG_fail;
25392 temp2 = true;
25393 }
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 (arg1)->SetText((wxString const &)*arg2);
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_Py_Void();
25401 {
25402 if (temp2)
25403 delete arg2;
25404 }
25405 return resultobj;
25406 fail:
25407 {
25408 if (temp2)
25409 delete arg2;
25410 }
25411 return NULL;
25412 }
25413
25414
25415 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj = 0;
25417 long arg1 ;
25418 long val1 ;
25419 int ecode1 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char * kwnames[] = {
25422 (char *) "updateInterval", NULL
25423 };
25424
25425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25426 ecode1 = SWIG_AsVal_long(obj0, &val1);
25427 if (!SWIG_IsOK(ecode1)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25429 }
25430 arg1 = static_cast< long >(val1);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 wxUpdateUIEvent::SetUpdateInterval(arg1);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_Py_Void();
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 long result;
25447
25448 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 resultobj = SWIG_From_long(static_cast< long >(result));
25456 return resultobj;
25457 fail:
25458 return NULL;
25459 }
25460
25461
25462 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj = 0;
25464 wxWindow *arg1 = (wxWindow *) 0 ;
25465 bool result;
25466 void *argp1 = 0 ;
25467 int res1 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "win", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25477 }
25478 arg1 = reinterpret_cast< wxWindow * >(argp1);
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25487 }
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 wxUpdateUIEvent::ResetUpdateTime();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_Py_Void();
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25512 PyObject *resultobj = 0;
25513 wxUpdateUIMode arg1 ;
25514 int val1 ;
25515 int ecode1 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "mode", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25522 ecode1 = SWIG_AsVal_int(obj0, &val1);
25523 if (!SWIG_IsOK(ecode1)) {
25524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25525 }
25526 arg1 = static_cast< wxUpdateUIMode >(val1);
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 wxUpdateUIEvent::SetMode(arg1);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxUpdateUIMode result;
25543
25544 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 resultobj = SWIG_From_int(static_cast< int >(result));
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *obj;
25560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25561 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25562 return SWIG_Py_Void();
25563 }
25564
25565 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 return SWIG_Python_InitShadowInstance(args);
25567 }
25568
25569 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 PyObject *resultobj = 0;
25571 wxSysColourChangedEvent *result = 0 ;
25572
25573 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *obj;
25589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25590 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25591 return SWIG_Py_Void();
25592 }
25593
25594 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 return SWIG_Python_InitShadowInstance(args);
25596 }
25597
25598 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj = 0;
25600 int arg1 = (int) 0 ;
25601 wxWindow *arg2 = (wxWindow *) NULL ;
25602 wxMouseCaptureChangedEvent *result = 0 ;
25603 int val1 ;
25604 int ecode1 = 0 ;
25605 void *argp2 = 0 ;
25606 int res2 = 0 ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 char * kwnames[] = {
25610 (char *) "winid",(char *) "gainedCapture", NULL
25611 };
25612
25613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25614 if (obj0) {
25615 ecode1 = SWIG_AsVal_int(obj0, &val1);
25616 if (!SWIG_IsOK(ecode1)) {
25617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25618 }
25619 arg1 = static_cast< int >(val1);
25620 }
25621 if (obj1) {
25622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25623 if (!SWIG_IsOK(res2)) {
25624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25625 }
25626 arg2 = reinterpret_cast< wxWindow * >(argp2);
25627 }
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25642 PyObject *resultobj = 0;
25643 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25644 wxWindow *result = 0 ;
25645 void *argp1 = 0 ;
25646 int res1 = 0 ;
25647 PyObject *swig_obj[1] ;
25648
25649 if (!args) SWIG_fail;
25650 swig_obj[0] = args;
25651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25652 if (!SWIG_IsOK(res1)) {
25653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25654 }
25655 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 {
25663 resultobj = wxPyMake_wxObject(result, (bool)0);
25664 }
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *obj;
25673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25675 return SWIG_Py_Void();
25676 }
25677
25678 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 return SWIG_Python_InitShadowInstance(args);
25680 }
25681
25682 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj = 0;
25684 int arg1 = (int) 0 ;
25685 wxMouseCaptureLostEvent *result = 0 ;
25686 int val1 ;
25687 int ecode1 = 0 ;
25688 PyObject * obj0 = 0 ;
25689 char * kwnames[] = {
25690 (char *) "winid", NULL
25691 };
25692
25693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25694 if (obj0) {
25695 ecode1 = SWIG_AsVal_int(obj0, &val1);
25696 if (!SWIG_IsOK(ecode1)) {
25697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25698 }
25699 arg1 = static_cast< int >(val1);
25700 }
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *obj;
25716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25717 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25718 return SWIG_Py_Void();
25719 }
25720
25721 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 return SWIG_Python_InitShadowInstance(args);
25723 }
25724
25725 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 PyObject *resultobj = 0;
25727 wxDisplayChangedEvent *result = 0 ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25744 PyObject *obj;
25745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25746 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25747 return SWIG_Py_Void();
25748 }
25749
25750 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25751 return SWIG_Python_InitShadowInstance(args);
25752 }
25753
25754 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj = 0;
25756 int arg1 = (int) 0 ;
25757 wxPaletteChangedEvent *result = 0 ;
25758 int val1 ;
25759 int ecode1 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 char * kwnames[] = {
25762 (char *) "id", NULL
25763 };
25764
25765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25766 if (obj0) {
25767 ecode1 = SWIG_AsVal_int(obj0, &val1);
25768 if (!SWIG_IsOK(ecode1)) {
25769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25770 }
25771 arg1 = static_cast< int >(val1);
25772 }
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25780 return resultobj;
25781 fail:
25782 return NULL;
25783 }
25784
25785
25786 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25787 PyObject *resultobj = 0;
25788 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25789 wxWindow *arg2 = (wxWindow *) 0 ;
25790 void *argp1 = 0 ;
25791 int res1 = 0 ;
25792 void *argp2 = 0 ;
25793 int res2 = 0 ;
25794 PyObject * obj0 = 0 ;
25795 PyObject * obj1 = 0 ;
25796 char * kwnames[] = {
25797 (char *) "self",(char *) "win", NULL
25798 };
25799
25800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25802 if (!SWIG_IsOK(res1)) {
25803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25804 }
25805 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25807 if (!SWIG_IsOK(res2)) {
25808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25809 }
25810 arg2 = reinterpret_cast< wxWindow * >(argp2);
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 (arg1)->SetChangedWindow(arg2);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_Py_Void();
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25825 PyObject *resultobj = 0;
25826 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25827 wxWindow *result = 0 ;
25828 void *argp1 = 0 ;
25829 int res1 = 0 ;
25830 PyObject *swig_obj[1] ;
25831
25832 if (!args) SWIG_fail;
25833 swig_obj[0] = args;
25834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25835 if (!SWIG_IsOK(res1)) {
25836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25837 }
25838 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 result = (wxWindow *)(arg1)->GetChangedWindow();
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 {
25846 resultobj = wxPyMake_wxObject(result, (bool)0);
25847 }
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25855 PyObject *obj;
25856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25857 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25858 return SWIG_Py_Void();
25859 }
25860
25861 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25862 return SWIG_Python_InitShadowInstance(args);
25863 }
25864
25865 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj = 0;
25867 int arg1 = (int) 0 ;
25868 wxQueryNewPaletteEvent *result = 0 ;
25869 int val1 ;
25870 int ecode1 = 0 ;
25871 PyObject * obj0 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "winid", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25877 if (obj0) {
25878 ecode1 = SWIG_AsVal_int(obj0, &val1);
25879 if (!SWIG_IsOK(ecode1)) {
25880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25881 }
25882 arg1 = static_cast< int >(val1);
25883 }
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj = 0;
25899 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25900 bool arg2 ;
25901 void *argp1 = 0 ;
25902 int res1 = 0 ;
25903 bool val2 ;
25904 int ecode2 = 0 ;
25905 PyObject * obj0 = 0 ;
25906 PyObject * obj1 = 0 ;
25907 char * kwnames[] = {
25908 (char *) "self",(char *) "realized", NULL
25909 };
25910
25911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25913 if (!SWIG_IsOK(res1)) {
25914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25915 }
25916 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25918 if (!SWIG_IsOK(ecode2)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25920 }
25921 arg2 = static_cast< bool >(val2);
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 (arg1)->SetPaletteRealized(arg2);
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_Py_Void();
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25938 bool result;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 PyObject *swig_obj[1] ;
25942
25943 if (!args) SWIG_fail;
25944 swig_obj[0] = args;
25945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25948 }
25949 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25966 PyObject *obj;
25967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25968 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25969 return SWIG_Py_Void();
25970 }
25971
25972 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 return SWIG_Python_InitShadowInstance(args);
25974 }
25975
25976 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 PyObject *resultobj = 0;
25978 wxNavigationKeyEvent *result = 0 ;
25979
25980 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 PyObject *resultobj = 0;
25996 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25997 bool result;
25998 void *argp1 = 0 ;
25999 int res1 = 0 ;
26000 PyObject *swig_obj[1] ;
26001
26002 if (!args) SWIG_fail;
26003 swig_obj[0] = args;
26004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26005 if (!SWIG_IsOK(res1)) {
26006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26007 }
26008 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 {
26016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26027 bool arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 bool val2 ;
26031 int ecode2 = 0 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "self",(char *) "forward", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26042 }
26043 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26045 if (!SWIG_IsOK(ecode2)) {
26046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26047 }
26048 arg2 = static_cast< bool >(val2);
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->SetDirection(arg2);
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_Py_Void();
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26063 PyObject *resultobj = 0;
26064 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26065 bool result;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 PyObject *swig_obj[1] ;
26069
26070 if (!args) SWIG_fail;
26071 swig_obj[0] = args;
26072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26075 }
26076 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 {
26084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj = 0;
26094 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26095 bool arg2 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 bool val2 ;
26099 int ecode2 = 0 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 char * kwnames[] = {
26103 (char *) "self",(char *) "ischange", NULL
26104 };
26105
26106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26108 if (!SWIG_IsOK(res1)) {
26109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26110 }
26111 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26113 if (!SWIG_IsOK(ecode2)) {
26114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26115 }
26116 arg2 = static_cast< bool >(val2);
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 (arg1)->SetWindowChange(arg2);
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_Py_Void();
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26133 bool result;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 PyObject *swig_obj[1] ;
26137
26138 if (!args) SWIG_fail;
26139 swig_obj[0] = args;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26143 }
26144 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 {
26152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26153 }
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj = 0;
26162 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26163 bool arg2 ;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 bool val2 ;
26167 int ecode2 = 0 ;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 char * kwnames[] = {
26171 (char *) "self",(char *) "bIs", NULL
26172 };
26173
26174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26178 }
26179 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26181 if (!SWIG_IsOK(ecode2)) {
26182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26183 }
26184 arg2 = static_cast< bool >(val2);
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 (arg1)->SetFromTab(arg2);
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_Py_Void();
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj = 0;
26200 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26201 long arg2 ;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 long val2 ;
26205 int ecode2 = 0 ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char * kwnames[] = {
26209 (char *) "self",(char *) "flags", NULL
26210 };
26211
26212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26214 if (!SWIG_IsOK(res1)) {
26215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26216 }
26217 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26218 ecode2 = SWIG_AsVal_long(obj1, &val2);
26219 if (!SWIG_IsOK(ecode2)) {
26220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26221 }
26222 arg2 = static_cast< long >(val2);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 (arg1)->SetFlags(arg2);
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 resultobj = SWIG_Py_Void();
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26237 PyObject *resultobj = 0;
26238 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26239 wxWindow *result = 0 ;
26240 void *argp1 = 0 ;
26241 int res1 = 0 ;
26242 PyObject *swig_obj[1] ;
26243
26244 if (!args) SWIG_fail;
26245 swig_obj[0] = args;
26246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26247 if (!SWIG_IsOK(res1)) {
26248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26249 }
26250 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26251 {
26252 PyThreadState* __tstate = wxPyBeginAllowThreads();
26253 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26254 wxPyEndAllowThreads(__tstate);
26255 if (PyErr_Occurred()) SWIG_fail;
26256 }
26257 {
26258 resultobj = wxPyMake_wxObject(result, (bool)0);
26259 }
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26267 PyObject *resultobj = 0;
26268 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26269 wxWindow *arg2 = (wxWindow *) 0 ;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 void *argp2 = 0 ;
26273 int res2 = 0 ;
26274 PyObject * obj0 = 0 ;
26275 PyObject * obj1 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "self",(char *) "win", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26284 }
26285 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26287 if (!SWIG_IsOK(res2)) {
26288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26289 }
26290 arg2 = reinterpret_cast< wxWindow * >(argp2);
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 (arg1)->SetCurrentFocus(arg2);
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 resultobj = SWIG_Py_Void();
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *obj;
26306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26308 return SWIG_Py_Void();
26309 }
26310
26311 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 return SWIG_Python_InitShadowInstance(args);
26313 }
26314
26315 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj = 0;
26317 wxWindow *arg1 = (wxWindow *) NULL ;
26318 wxWindowCreateEvent *result = 0 ;
26319 void *argp1 = 0 ;
26320 int res1 = 0 ;
26321 PyObject * obj0 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "win", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26327 if (obj0) {
26328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26331 }
26332 arg1 = reinterpret_cast< wxWindow * >(argp1);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26350 wxWindow *result = 0 ;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = wxPyMake_wxObject(result, (bool)0);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *obj;
26379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26380 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26381 return SWIG_Py_Void();
26382 }
26383
26384 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 return SWIG_Python_InitShadowInstance(args);
26386 }
26387
26388 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxWindow *arg1 = (wxWindow *) NULL ;
26391 wxWindowDestroyEvent *result = 0 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject * obj0 = 0 ;
26395 char * kwnames[] = {
26396 (char *) "win", NULL
26397 };
26398
26399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26400 if (obj0) {
26401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26404 }
26405 arg1 = reinterpret_cast< wxWindow * >(argp1);
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26423 wxWindow *result = 0 ;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 PyObject *swig_obj[1] ;
26427
26428 if (!args) SWIG_fail;
26429 swig_obj[0] = args;
26430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26431 if (!SWIG_IsOK(res1)) {
26432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26433 }
26434 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 {
26442 resultobj = wxPyMake_wxObject(result, (bool)0);
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26451 PyObject *obj;
26452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26453 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26454 return SWIG_Py_Void();
26455 }
26456
26457 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26458 return SWIG_Python_InitShadowInstance(args);
26459 }
26460
26461 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26464 int arg2 = (int) 0 ;
26465 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26466 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26467 wxContextMenuEvent *result = 0 ;
26468 int val1 ;
26469 int ecode1 = 0 ;
26470 int val2 ;
26471 int ecode2 = 0 ;
26472 wxPoint temp3 ;
26473 PyObject * obj0 = 0 ;
26474 PyObject * obj1 = 0 ;
26475 PyObject * obj2 = 0 ;
26476 char * kwnames[] = {
26477 (char *) "type",(char *) "winid",(char *) "pt", NULL
26478 };
26479
26480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26481 if (obj0) {
26482 ecode1 = SWIG_AsVal_int(obj0, &val1);
26483 if (!SWIG_IsOK(ecode1)) {
26484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26485 }
26486 arg1 = static_cast< wxEventType >(val1);
26487 }
26488 if (obj1) {
26489 ecode2 = SWIG_AsVal_int(obj1, &val2);
26490 if (!SWIG_IsOK(ecode2)) {
26491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26492 }
26493 arg2 = static_cast< int >(val2);
26494 }
26495 if (obj2) {
26496 {
26497 arg3 = &temp3;
26498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26499 }
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26508 return resultobj;
26509 fail:
26510 return NULL;
26511 }
26512
26513
26514 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26515 PyObject *resultobj = 0;
26516 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26517 wxPoint *result = 0 ;
26518 void *argp1 = 0 ;
26519 int res1 = 0 ;
26520 PyObject *swig_obj[1] ;
26521
26522 if (!args) SWIG_fail;
26523 swig_obj[0] = args;
26524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26527 }
26528 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 {
26532 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26533 result = (wxPoint *) &_result_ref;
26534 }
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26548 wxPoint *arg2 = 0 ;
26549 void *argp1 = 0 ;
26550 int res1 = 0 ;
26551 wxPoint temp2 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char * kwnames[] = {
26555 (char *) "self",(char *) "pos", NULL
26556 };
26557
26558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26560 if (!SWIG_IsOK(res1)) {
26561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26562 }
26563 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26564 {
26565 arg2 = &temp2;
26566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26567 }
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 (arg1)->SetPosition((wxPoint const &)*arg2);
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 resultobj = SWIG_Py_Void();
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 PyObject *obj;
26583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26584 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26585 return SWIG_Py_Void();
26586 }
26587
26588 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26589 return SWIG_Python_InitShadowInstance(args);
26590 }
26591
26592 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxIdleEvent *result = 0 ;
26595
26596 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (wxIdleEvent *)new wxIdleEvent();
26600 wxPyEndAllowThreads(__tstate);
26601 if (PyErr_Occurred()) SWIG_fail;
26602 }
26603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26604 return resultobj;
26605 fail:
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj = 0;
26612 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26613 bool arg2 = (bool) true ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 bool val2 ;
26617 int ecode2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "needMore", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26628 }
26629 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26630 if (obj1) {
26631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26634 }
26635 arg2 = static_cast< bool >(val2);
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 (arg1)->RequestMore(arg2);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = SWIG_Py_Void();
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26651 PyObject *resultobj = 0;
26652 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26653 bool result;
26654 void *argp1 = 0 ;
26655 int res1 = 0 ;
26656 PyObject *swig_obj[1] ;
26657
26658 if (!args) SWIG_fail;
26659 swig_obj[0] = args;
26660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26661 if (!SWIG_IsOK(res1)) {
26662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26663 }
26664 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 {
26672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26673 }
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26681 PyObject *resultobj = 0;
26682 wxIdleMode arg1 ;
26683 int val1 ;
26684 int ecode1 = 0 ;
26685 PyObject * obj0 = 0 ;
26686 char * kwnames[] = {
26687 (char *) "mode", NULL
26688 };
26689
26690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26691 ecode1 = SWIG_AsVal_int(obj0, &val1);
26692 if (!SWIG_IsOK(ecode1)) {
26693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26694 }
26695 arg1 = static_cast< wxIdleMode >(val1);
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 wxIdleEvent::SetMode(arg1);
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 resultobj = SWIG_Py_Void();
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 PyObject *resultobj = 0;
26711 wxIdleMode result;
26712
26713 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 result = (wxIdleMode)wxIdleEvent::GetMode();
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 resultobj = SWIG_From_int(static_cast< int >(result));
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj = 0;
26729 wxWindow *arg1 = (wxWindow *) 0 ;
26730 bool result;
26731 void *argp1 = 0 ;
26732 int res1 = 0 ;
26733 PyObject * obj0 = 0 ;
26734 char * kwnames[] = {
26735 (char *) "win", NULL
26736 };
26737
26738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26742 }
26743 arg1 = reinterpret_cast< wxWindow * >(argp1);
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)wxIdleEvent::CanSend(arg1);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 {
26751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26752 }
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26760 PyObject *obj;
26761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26762 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26763 return SWIG_Py_Void();
26764 }
26765
26766 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 return SWIG_Python_InitShadowInstance(args);
26768 }
26769
26770 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26773 int arg2 = (int) 0 ;
26774 wxClipboardTextEvent *result = 0 ;
26775 int val1 ;
26776 int ecode1 = 0 ;
26777 int val2 ;
26778 int ecode2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "type",(char *) "winid", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26786 if (obj0) {
26787 ecode1 = SWIG_AsVal_int(obj0, &val1);
26788 if (!SWIG_IsOK(ecode1)) {
26789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26790 }
26791 arg1 = static_cast< wxEventType >(val1);
26792 }
26793 if (obj1) {
26794 ecode2 = SWIG_AsVal_int(obj1, &val2);
26795 if (!SWIG_IsOK(ecode2)) {
26796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26797 }
26798 arg2 = static_cast< int >(val2);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *obj;
26815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26816 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26817 return SWIG_Py_Void();
26818 }
26819
26820 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26821 return SWIG_Python_InitShadowInstance(args);
26822 }
26823
26824 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj = 0;
26826 int arg1 = (int) 0 ;
26827 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26828 wxPyEvent *result = 0 ;
26829 int val1 ;
26830 int ecode1 = 0 ;
26831 int val2 ;
26832 int ecode2 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "winid",(char *) "eventType", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26840 if (obj0) {
26841 ecode1 = SWIG_AsVal_int(obj0, &val1);
26842 if (!SWIG_IsOK(ecode1)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26844 }
26845 arg1 = static_cast< int >(val1);
26846 }
26847 if (obj1) {
26848 ecode2 = SWIG_AsVal_int(obj1, &val2);
26849 if (!SWIG_IsOK(ecode2)) {
26850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26851 }
26852 arg2 = static_cast< wxEventType >(val2);
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26868 PyObject *resultobj = 0;
26869 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26870 void *argp1 = 0 ;
26871 int res1 = 0 ;
26872 PyObject *swig_obj[1] ;
26873
26874 if (!args) SWIG_fail;
26875 swig_obj[0] = args;
26876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26877 if (!SWIG_IsOK(res1)) {
26878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26879 }
26880 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 delete arg1;
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 resultobj = SWIG_Py_Void();
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj = 0;
26897 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26898 PyObject *arg2 = (PyObject *) 0 ;
26899 void *argp1 = 0 ;
26900 int res1 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "self", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26911 }
26912 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26913 arg2 = obj1;
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 (arg1)->SetSelf(arg2);
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_Py_Void();
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26928 PyObject *resultobj = 0;
26929 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26930 PyObject *result = 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 PyObject *swig_obj[1] ;
26934
26935 if (!args) SWIG_fail;
26936 swig_obj[0] = args;
26937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26938 if (!SWIG_IsOK(res1)) {
26939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26940 }
26941 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = (PyObject *)(arg1)->GetSelf();
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 resultobj = result;
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 PyObject *obj;
26957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26958 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26959 return SWIG_Py_Void();
26960 }
26961
26962 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 return SWIG_Python_InitShadowInstance(args);
26964 }
26965
26966 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj = 0;
26968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26969 int arg2 = (int) 0 ;
26970 wxPyCommandEvent *result = 0 ;
26971 int val1 ;
26972 int ecode1 = 0 ;
26973 int val2 ;
26974 int ecode2 = 0 ;
26975 PyObject * obj0 = 0 ;
26976 PyObject * obj1 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "eventType",(char *) "id", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26982 if (obj0) {
26983 ecode1 = SWIG_AsVal_int(obj0, &val1);
26984 if (!SWIG_IsOK(ecode1)) {
26985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26986 }
26987 arg1 = static_cast< wxEventType >(val1);
26988 }
26989 if (obj1) {
26990 ecode2 = SWIG_AsVal_int(obj1, &val2);
26991 if (!SWIG_IsOK(ecode2)) {
26992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26993 }
26994 arg2 = static_cast< int >(val2);
26995 }
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27003 return resultobj;
27004 fail:
27005 return NULL;
27006 }
27007
27008
27009 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27010 PyObject *resultobj = 0;
27011 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27012 void *argp1 = 0 ;
27013 int res1 = 0 ;
27014 PyObject *swig_obj[1] ;
27015
27016 if (!args) SWIG_fail;
27017 swig_obj[0] = args;
27018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27019 if (!SWIG_IsOK(res1)) {
27020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27021 }
27022 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 delete arg1;
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj = 0;
27039 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27040 PyObject *arg2 = (PyObject *) 0 ;
27041 void *argp1 = 0 ;
27042 int res1 = 0 ;
27043 PyObject * obj0 = 0 ;
27044 PyObject * obj1 = 0 ;
27045 char * kwnames[] = {
27046 (char *) "self",(char *) "self", NULL
27047 };
27048
27049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27051 if (!SWIG_IsOK(res1)) {
27052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27053 }
27054 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27055 arg2 = obj1;
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 (arg1)->SetSelf(arg2);
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 resultobj = SWIG_Py_Void();
27063 return resultobj;
27064 fail:
27065 return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27070 PyObject *resultobj = 0;
27071 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27072 PyObject *result = 0 ;
27073 void *argp1 = 0 ;
27074 int res1 = 0 ;
27075 PyObject *swig_obj[1] ;
27076
27077 if (!args) SWIG_fail;
27078 swig_obj[0] = args;
27079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27080 if (!SWIG_IsOK(res1)) {
27081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27082 }
27083 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (PyObject *)(arg1)->GetSelf();
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = result;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27098 PyObject *obj;
27099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27100 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27101 return SWIG_Py_Void();
27102 }
27103
27104 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 return SWIG_Python_InitShadowInstance(args);
27106 }
27107
27108 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj = 0;
27110 wxWindow *arg1 = (wxWindow *) 0 ;
27111 wxDateTime *arg2 = 0 ;
27112 wxEventType arg3 ;
27113 wxDateEvent *result = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 void *argp2 = 0 ;
27117 int res2 = 0 ;
27118 int val3 ;
27119 int ecode3 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 PyObject * obj2 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "win",(char *) "dt",(char *) "type", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27129 if (!SWIG_IsOK(res1)) {
27130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27131 }
27132 arg1 = reinterpret_cast< wxWindow * >(argp1);
27133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27134 if (!SWIG_IsOK(res2)) {
27135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27136 }
27137 if (!argp2) {
27138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27139 }
27140 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27141 ecode3 = SWIG_AsVal_int(obj2, &val3);
27142 if (!SWIG_IsOK(ecode3)) {
27143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27144 }
27145 arg3 = static_cast< wxEventType >(val3);
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 PyObject *resultobj = 0;
27161 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27162 wxDateTime *result = 0 ;
27163 void *argp1 = 0 ;
27164 int res1 = 0 ;
27165 PyObject *swig_obj[1] ;
27166
27167 if (!args) SWIG_fail;
27168 swig_obj[0] = args;
27169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27170 if (!SWIG_IsOK(res1)) {
27171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27172 }
27173 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 {
27177 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27178 result = (wxDateTime *) &_result_ref;
27179 }
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj = 0;
27192 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27193 wxDateTime *arg2 = 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 void *argp2 = 0 ;
27197 int res2 = 0 ;
27198 PyObject * obj0 = 0 ;
27199 PyObject * obj1 = 0 ;
27200 char * kwnames[] = {
27201 (char *) "self",(char *) "date", NULL
27202 };
27203
27204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27206 if (!SWIG_IsOK(res1)) {
27207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27208 }
27209 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27210 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27211 if (!SWIG_IsOK(res2)) {
27212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27213 }
27214 if (!argp2) {
27215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27216 }
27217 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27218 {
27219 PyThreadState* __tstate = wxPyBeginAllowThreads();
27220 (arg1)->SetDate((wxDateTime const &)*arg2);
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 resultobj = SWIG_Py_Void();
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27232 PyObject *obj;
27233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27234 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27235 return SWIG_Py_Void();
27236 }
27237
27238 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27239 return SWIG_Python_InitShadowInstance(args);
27240 }
27241
27242 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27243 PyObject *resultobj = 0;
27244 wxPyApp *result = 0 ;
27245
27246 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 result = (wxPyApp *)new_wxPyApp();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27261 PyObject *resultobj = 0;
27262 wxPyApp *arg1 = (wxPyApp *) 0 ;
27263 void *argp1 = 0 ;
27264 int res1 = 0 ;
27265 PyObject *swig_obj[1] ;
27266
27267 if (!args) SWIG_fail;
27268 swig_obj[0] = args;
27269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27272 }
27273 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 delete arg1;
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_Py_Void();
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj = 0;
27290 wxPyApp *arg1 = (wxPyApp *) 0 ;
27291 PyObject *arg2 = (PyObject *) 0 ;
27292 PyObject *arg3 = (PyObject *) 0 ;
27293 bool arg4 ;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 bool val4 ;
27297 int ecode4 = 0 ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 PyObject * obj2 = 0 ;
27301 PyObject * obj3 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 arg2 = obj1;
27313 arg3 = obj2;
27314 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27315 if (!SWIG_IsOK(ecode4)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27317 }
27318 arg4 = static_cast< bool >(val4);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_Py_Void();
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxPyApp *arg1 = (wxPyApp *) 0 ;
27335 wxString result;
27336 void *argp1 = 0 ;
27337 int res1 = 0 ;
27338 PyObject *swig_obj[1] ;
27339
27340 if (!args) SWIG_fail;
27341 swig_obj[0] = args;
27342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27345 }
27346 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 result = ((wxPyApp const *)arg1)->GetAppName();
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 {
27354 #if wxUSE_UNICODE
27355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27356 #else
27357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27358 #endif
27359 }
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj = 0;
27368 wxPyApp *arg1 = (wxPyApp *) 0 ;
27369 wxString *arg2 = 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 bool temp2 = false ;
27373 PyObject * obj0 = 0 ;
27374 PyObject * obj1 = 0 ;
27375 char * kwnames[] = {
27376 (char *) "self",(char *) "name", NULL
27377 };
27378
27379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27383 }
27384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27385 {
27386 arg2 = wxString_in_helper(obj1);
27387 if (arg2 == NULL) SWIG_fail;
27388 temp2 = true;
27389 }
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 (arg1)->SetAppName((wxString const &)*arg2);
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_Py_Void();
27397 {
27398 if (temp2)
27399 delete arg2;
27400 }
27401 return resultobj;
27402 fail:
27403 {
27404 if (temp2)
27405 delete arg2;
27406 }
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27412 PyObject *resultobj = 0;
27413 wxPyApp *arg1 = (wxPyApp *) 0 ;
27414 wxString result;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 PyObject *swig_obj[1] ;
27418
27419 if (!args) SWIG_fail;
27420 swig_obj[0] = args;
27421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27422 if (!SWIG_IsOK(res1)) {
27423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27424 }
27425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = ((wxPyApp const *)arg1)->GetClassName();
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 #if wxUSE_UNICODE
27434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27435 #else
27436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27437 #endif
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj = 0;
27447 wxPyApp *arg1 = (wxPyApp *) 0 ;
27448 wxString *arg2 = 0 ;
27449 void *argp1 = 0 ;
27450 int res1 = 0 ;
27451 bool temp2 = false ;
27452 PyObject * obj0 = 0 ;
27453 PyObject * obj1 = 0 ;
27454 char * kwnames[] = {
27455 (char *) "self",(char *) "name", NULL
27456 };
27457
27458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27464 {
27465 arg2 = wxString_in_helper(obj1);
27466 if (arg2 == NULL) SWIG_fail;
27467 temp2 = true;
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetClassName((wxString const &)*arg2);
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 {
27477 if (temp2)
27478 delete arg2;
27479 }
27480 return resultobj;
27481 fail:
27482 {
27483 if (temp2)
27484 delete arg2;
27485 }
27486 return NULL;
27487 }
27488
27489
27490 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27491 PyObject *resultobj = 0;
27492 wxPyApp *arg1 = (wxPyApp *) 0 ;
27493 wxString *result = 0 ;
27494 void *argp1 = 0 ;
27495 int res1 = 0 ;
27496 PyObject *swig_obj[1] ;
27497
27498 if (!args) SWIG_fail;
27499 swig_obj[0] = args;
27500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27501 if (!SWIG_IsOK(res1)) {
27502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27503 }
27504 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 {
27508 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27509 result = (wxString *) &_result_ref;
27510 }
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 {
27515 #if wxUSE_UNICODE
27516 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27517 #else
27518 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27519 #endif
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 wxString *arg2 = 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 bool temp2 = false ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 char * kwnames[] = {
27537 (char *) "self",(char *) "name", NULL
27538 };
27539
27540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27542 if (!SWIG_IsOK(res1)) {
27543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27544 }
27545 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27546 {
27547 arg2 = wxString_in_helper(obj1);
27548 if (arg2 == NULL) SWIG_fail;
27549 temp2 = true;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetVendorName((wxString const &)*arg2);
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 resultobj = SWIG_Py_Void();
27558 {
27559 if (temp2)
27560 delete arg2;
27561 }
27562 return resultobj;
27563 fail:
27564 {
27565 if (temp2)
27566 delete arg2;
27567 }
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 wxPyApp *arg1 = (wxPyApp *) 0 ;
27575 wxAppTraits *result = 0 ;
27576 void *argp1 = 0 ;
27577 int res1 = 0 ;
27578 PyObject *swig_obj[1] ;
27579
27580 if (!args) SWIG_fail;
27581 swig_obj[0] = args;
27582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27583 if (!SWIG_IsOK(res1)) {
27584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27585 }
27586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (wxAppTraits *)(arg1)->GetTraits();
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *resultobj = 0;
27602 wxPyApp *arg1 = (wxPyApp *) 0 ;
27603 void *argp1 = 0 ;
27604 int res1 = 0 ;
27605 PyObject *swig_obj[1] ;
27606
27607 if (!args) SWIG_fail;
27608 swig_obj[0] = args;
27609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27610 if (!SWIG_IsOK(res1)) {
27611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27612 }
27613 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 (arg1)->ProcessPendingEvents();
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 resultobj = SWIG_Py_Void();
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27628 PyObject *resultobj = 0;
27629 wxPyApp *arg1 = (wxPyApp *) 0 ;
27630 bool arg2 = (bool) false ;
27631 bool result;
27632 void *argp1 = 0 ;
27633 int res1 = 0 ;
27634 bool val2 ;
27635 int ecode2 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 PyObject * obj1 = 0 ;
27638 char * kwnames[] = {
27639 (char *) "self",(char *) "onlyIfNeeded", NULL
27640 };
27641
27642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 if (obj1) {
27649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27650 if (!SWIG_IsOK(ecode2)) {
27651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27652 }
27653 arg2 = static_cast< bool >(val2);
27654 }
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (bool)(arg1)->Yield(arg2);
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 {
27662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27663 }
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27671 PyObject *resultobj = 0;
27672 wxPyApp *arg1 = (wxPyApp *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 PyObject *swig_obj[1] ;
27676
27677 if (!args) SWIG_fail;
27678 swig_obj[0] = args;
27679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27680 if (!SWIG_IsOK(res1)) {
27681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27682 }
27683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->WakeUpIdle();
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = SWIG_Py_Void();
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27698 PyObject *resultobj = 0;
27699 bool result;
27700
27701 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 result = (bool)wxPyApp::IsMainLoopRunning();
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 {
27709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27710 }
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 int result;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 PyObject *swig_obj[1] ;
27724
27725 if (!args) SWIG_fail;
27726 swig_obj[0] = args;
27727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27728 if (!SWIG_IsOK(res1)) {
27729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27730 }
27731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (int)(arg1)->MainLoop();
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_From_int(static_cast< int >(result));
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 void *argp1 = 0 ;
27749 int res1 = 0 ;
27750 PyObject *swig_obj[1] ;
27751
27752 if (!args) SWIG_fail;
27753 swig_obj[0] = args;
27754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27755 if (!SWIG_IsOK(res1)) {
27756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27757 }
27758 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 (arg1)->Exit();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = SWIG_Py_Void();
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27773 PyObject *resultobj = 0;
27774 wxPyApp *arg1 = (wxPyApp *) 0 ;
27775 wxLayoutDirection result;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 PyObject *swig_obj[1] ;
27779
27780 if (!args) SWIG_fail;
27781 swig_obj[0] = args;
27782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27783 if (!SWIG_IsOK(res1)) {
27784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27785 }
27786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = ((wxPyApp const *)arg1)->GetLayoutDirection();
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27801 PyObject *resultobj = 0;
27802 wxPyApp *arg1 = (wxPyApp *) 0 ;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 PyObject *swig_obj[1] ;
27806
27807 if (!args) SWIG_fail;
27808 swig_obj[0] = args;
27809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27810 if (!SWIG_IsOK(res1)) {
27811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27812 }
27813 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->ExitMainLoop();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_Py_Void();
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 wxPyApp *arg1 = (wxPyApp *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 PyObject *swig_obj[1] ;
27834
27835 if (!args) SWIG_fail;
27836 swig_obj[0] = args;
27837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27840 }
27841 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (bool)(arg1)->Pending();
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27858 PyObject *resultobj = 0;
27859 wxPyApp *arg1 = (wxPyApp *) 0 ;
27860 bool result;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 PyObject *swig_obj[1] ;
27864
27865 if (!args) SWIG_fail;
27866 swig_obj[0] = args;
27867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27870 }
27871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (bool)(arg1)->Dispatch();
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 {
27879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27880 }
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27888 PyObject *resultobj = 0;
27889 wxPyApp *arg1 = (wxPyApp *) 0 ;
27890 bool result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 PyObject *swig_obj[1] ;
27894
27895 if (!args) SWIG_fail;
27896 swig_obj[0] = args;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27900 }
27901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 result = (bool)(arg1)->ProcessIdle();
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj = 0;
27919 wxPyApp *arg1 = (wxPyApp *) 0 ;
27920 wxWindow *arg2 = (wxWindow *) 0 ;
27921 wxIdleEvent *arg3 = 0 ;
27922 bool result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 void *argp2 = 0 ;
27926 int res2 = 0 ;
27927 void *argp3 = 0 ;
27928 int res3 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 PyObject * obj2 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "win",(char *) "event", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27943 if (!SWIG_IsOK(res2)) {
27944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27945 }
27946 arg2 = reinterpret_cast< wxWindow * >(argp2);
27947 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27948 if (!SWIG_IsOK(res3)) {
27949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27950 }
27951 if (!argp3) {
27952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27953 }
27954 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27955 {
27956 PyThreadState* __tstate = wxPyBeginAllowThreads();
27957 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 {
27962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27963 }
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27971 PyObject *resultobj = 0;
27972 wxPyApp *arg1 = (wxPyApp *) 0 ;
27973 bool result;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 PyObject *swig_obj[1] ;
27977
27978 if (!args) SWIG_fail;
27979 swig_obj[0] = args;
27980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27981 if (!SWIG_IsOK(res1)) {
27982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27983 }
27984 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 result = (bool)((wxPyApp const *)arg1)->IsActive();
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 {
27992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27993 }
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj = 0;
28002 wxPyApp *arg1 = (wxPyApp *) 0 ;
28003 wxWindow *arg2 = (wxWindow *) 0 ;
28004 void *argp1 = 0 ;
28005 int res1 = 0 ;
28006 void *argp2 = 0 ;
28007 int res2 = 0 ;
28008 PyObject * obj0 = 0 ;
28009 PyObject * obj1 = 0 ;
28010 char * kwnames[] = {
28011 (char *) "self",(char *) "win", NULL
28012 };
28013
28014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28016 if (!SWIG_IsOK(res1)) {
28017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28018 }
28019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28021 if (!SWIG_IsOK(res2)) {
28022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28023 }
28024 arg2 = reinterpret_cast< wxWindow * >(argp2);
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 (arg1)->SetTopWindow(arg2);
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 resultobj = SWIG_Py_Void();
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28039 PyObject *resultobj = 0;
28040 wxPyApp *arg1 = (wxPyApp *) 0 ;
28041 wxWindow *result = 0 ;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 PyObject *swig_obj[1] ;
28045
28046 if (!args) SWIG_fail;
28047 swig_obj[0] = args;
28048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28049 if (!SWIG_IsOK(res1)) {
28050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28051 }
28052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 {
28060 resultobj = wxPyMake_wxObject(result, (bool)0);
28061 }
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 bool arg2 ;
28072 void *argp1 = 0 ;
28073 int res1 = 0 ;
28074 bool val2 ;
28075 int ecode2 = 0 ;
28076 PyObject * obj0 = 0 ;
28077 PyObject * obj1 = 0 ;
28078 char * kwnames[] = {
28079 (char *) "self",(char *) "flag", NULL
28080 };
28081
28082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28084 if (!SWIG_IsOK(res1)) {
28085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28086 }
28087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28089 if (!SWIG_IsOK(ecode2)) {
28090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28091 }
28092 arg2 = static_cast< bool >(val2);
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 (arg1)->SetExitOnFrameDelete(arg2);
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_Py_Void();
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28107 PyObject *resultobj = 0;
28108 wxPyApp *arg1 = (wxPyApp *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 PyObject *swig_obj[1] ;
28113
28114 if (!args) SWIG_fail;
28115 swig_obj[0] = args;
28116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28119 }
28120 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj = 0;
28138 wxPyApp *arg1 = (wxPyApp *) 0 ;
28139 bool arg2 ;
28140 void *argp1 = 0 ;
28141 int res1 = 0 ;
28142 bool val2 ;
28143 int ecode2 = 0 ;
28144 PyObject * obj0 = 0 ;
28145 PyObject * obj1 = 0 ;
28146 char * kwnames[] = {
28147 (char *) "self",(char *) "flag", NULL
28148 };
28149
28150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28154 }
28155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28157 if (!SWIG_IsOK(ecode2)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28159 }
28160 arg2 = static_cast< bool >(val2);
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 (arg1)->SetUseBestVisual(arg2);
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 resultobj = SWIG_Py_Void();
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28175 PyObject *resultobj = 0;
28176 wxPyApp *arg1 = (wxPyApp *) 0 ;
28177 bool result;
28178 void *argp1 = 0 ;
28179 int res1 = 0 ;
28180 PyObject *swig_obj[1] ;
28181
28182 if (!args) SWIG_fail;
28183 swig_obj[0] = args;
28184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28187 }
28188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28205 PyObject *resultobj = 0;
28206 wxPyApp *arg1 = (wxPyApp *) 0 ;
28207 int arg2 ;
28208 void *argp1 = 0 ;
28209 int res1 = 0 ;
28210 int val2 ;
28211 int ecode2 = 0 ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "self",(char *) "mode", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28222 }
28223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28224 ecode2 = SWIG_AsVal_int(obj1, &val2);
28225 if (!SWIG_IsOK(ecode2)) {
28226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28227 }
28228 arg2 = static_cast< int >(val2);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 (arg1)->SetPrintMode(arg2);
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_Py_Void();
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 wxPyApp *arg1 = (wxPyApp *) 0 ;
28245 int result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 PyObject *swig_obj[1] ;
28249
28250 if (!args) SWIG_fail;
28251 swig_obj[0] = args;
28252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28253 if (!SWIG_IsOK(res1)) {
28254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28255 }
28256 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_From_int(static_cast< int >(result));
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28271 PyObject *resultobj = 0;
28272 wxPyApp *arg1 = (wxPyApp *) 0 ;
28273 int arg2 ;
28274 void *argp1 = 0 ;
28275 int res1 = 0 ;
28276 int val2 ;
28277 int ecode2 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char * kwnames[] = {
28281 (char *) "self",(char *) "mode", NULL
28282 };
28283
28284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28286 if (!SWIG_IsOK(res1)) {
28287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28288 }
28289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28290 ecode2 = SWIG_AsVal_int(obj1, &val2);
28291 if (!SWIG_IsOK(ecode2)) {
28292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28293 }
28294 arg2 = static_cast< int >(val2);
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 (arg1)->SetAssertMode(arg2);
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 resultobj = SWIG_Py_Void();
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28309 PyObject *resultobj = 0;
28310 wxPyApp *arg1 = (wxPyApp *) 0 ;
28311 int result;
28312 void *argp1 = 0 ;
28313 int res1 = 0 ;
28314 PyObject *swig_obj[1] ;
28315
28316 if (!args) SWIG_fail;
28317 swig_obj[0] = args;
28318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28319 if (!SWIG_IsOK(res1)) {
28320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28321 }
28322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (int)(arg1)->GetAssertMode();
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_From_int(static_cast< int >(result));
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *resultobj = 0;
28338 bool result;
28339
28340 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28357 PyObject *resultobj = 0;
28358 long result;
28359
28360 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (long)wxPyApp::GetMacAboutMenuItemId();
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 resultobj = SWIG_From_long(static_cast< long >(result));
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 long result;
28377
28378 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 resultobj = SWIG_From_long(static_cast< long >(result));
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28393 PyObject *resultobj = 0;
28394 long result;
28395
28396 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 result = (long)wxPyApp::GetMacExitMenuItemId();
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 resultobj = SWIG_From_long(static_cast< long >(result));
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 PyObject *resultobj = 0;
28412 wxString result;
28413
28414 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = wxPyApp::GetMacHelpMenuTitleName();
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 #if wxUSE_UNICODE
28423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28424 #else
28425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28426 #endif
28427 }
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = 0;
28436 bool arg1 ;
28437 bool val1 ;
28438 int ecode1 = 0 ;
28439 PyObject * obj0 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "val", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28445 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28446 if (!SWIG_IsOK(ecode1)) {
28447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28448 }
28449 arg1 = static_cast< bool >(val1);
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_Py_Void();
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj = 0;
28465 long arg1 ;
28466 long val1 ;
28467 int ecode1 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "val", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28474 ecode1 = SWIG_AsVal_long(obj0, &val1);
28475 if (!SWIG_IsOK(ecode1)) {
28476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28477 }
28478 arg1 = static_cast< long >(val1);
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 wxPyApp::SetMacAboutMenuItemId(arg1);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 long arg1 ;
28495 long val1 ;
28496 int ecode1 = 0 ;
28497 PyObject * obj0 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "val", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28503 ecode1 = SWIG_AsVal_long(obj0, &val1);
28504 if (!SWIG_IsOK(ecode1)) {
28505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28506 }
28507 arg1 = static_cast< long >(val1);
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_Py_Void();
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 long arg1 ;
28524 long val1 ;
28525 int ecode1 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 char * kwnames[] = {
28528 (char *) "val", NULL
28529 };
28530
28531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28532 ecode1 = SWIG_AsVal_long(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28535 }
28536 arg1 = static_cast< long >(val1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 wxPyApp::SetMacExitMenuItemId(arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_Py_Void();
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 wxString *arg1 = 0 ;
28553 bool temp1 = false ;
28554 PyObject * obj0 = 0 ;
28555 char * kwnames[] = {
28556 (char *) "val", NULL
28557 };
28558
28559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28560 {
28561 arg1 = wxString_in_helper(obj0);
28562 if (arg1 == NULL) SWIG_fail;
28563 temp1 = true;
28564 }
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 {
28573 if (temp1)
28574 delete arg1;
28575 }
28576 return resultobj;
28577 fail:
28578 {
28579 if (temp1)
28580 delete arg1;
28581 }
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 wxPyApp *arg1 = (wxPyApp *) 0 ;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28598 }
28599 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->_BootstrapApp();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 resultobj = SWIG_Py_Void();
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 int result;
28616
28617 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (int)wxPyApp_GetComCtl32Version();
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 resultobj = SWIG_From_int(static_cast< int >(result));
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 bool result;
28634
28635 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (bool)wxPyApp_DisplayAvailable();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 {
28643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28644 }
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 PyObject *obj;
28653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28654 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28655 return SWIG_Py_Void();
28656 }
28657
28658 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 return SWIG_Python_InitShadowInstance(args);
28660 }
28661
28662 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28663 PyObject *resultobj = 0;
28664
28665 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 wxExit();
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 resultobj = SWIG_Py_Void();
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *resultobj = 0;
28681 bool result;
28682
28683 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 result = (bool)wxYield();
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 bool result;
28702
28703 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (bool)wxYieldIfNeeded();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28712 }
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj = 0;
28721 wxWindow *arg1 = (wxWindow *) NULL ;
28722 bool arg2 = (bool) false ;
28723 bool result;
28724 void *argp1 = 0 ;
28725 int res1 = 0 ;
28726 bool val2 ;
28727 int ecode2 = 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char * kwnames[] = {
28731 (char *) "win",(char *) "onlyIfNeeded", NULL
28732 };
28733
28734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28735 if (obj0) {
28736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28737 if (!SWIG_IsOK(res1)) {
28738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28739 }
28740 arg1 = reinterpret_cast< wxWindow * >(argp1);
28741 }
28742 if (obj1) {
28743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28744 if (!SWIG_IsOK(ecode2)) {
28745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28746 }
28747 arg2 = static_cast< bool >(val2);
28748 }
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)wxSafeYield(arg1,arg2);
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 {
28756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28757 }
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766
28767 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 wxWakeUpIdle();
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 resultobj = SWIG_Py_Void();
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28782 PyObject *resultobj = 0;
28783 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28784 wxEvent *arg2 = 0 ;
28785 void *argp1 = 0 ;
28786 int res1 = 0 ;
28787 void *argp2 = 0 ;
28788 int res2 = 0 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char * kwnames[] = {
28792 (char *) "dest",(char *) "event", NULL
28793 };
28794
28795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28797 if (!SWIG_IsOK(res1)) {
28798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28799 }
28800 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28802 if (!SWIG_IsOK(res2)) {
28803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28804 }
28805 if (!argp2) {
28806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28807 }
28808 arg2 = reinterpret_cast< wxEvent * >(argp2);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 wxPostEvent(arg1,*arg2);
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 resultobj = SWIG_Py_Void();
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28823 PyObject *resultobj = 0;
28824
28825 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 wxApp_CleanUp();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 resultobj = SWIG_Py_Void();
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxPyApp *result = 0 ;
28842
28843 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxPyApp *)wxPyGetApp();
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = wxPyMake_wxObject(result, 0);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj = 0;
28861 char *arg1 = (char *) 0 ;
28862 int res1 ;
28863 char *buf1 = 0 ;
28864 int alloc1 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "encoding", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28871 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28874 }
28875 arg1 = buf1;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 wxSetDefaultPyEncoding((char const *)arg1);
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_Py_Void();
28883 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28884 return resultobj;
28885 fail:
28886 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 char *result = 0 ;
28894
28895 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (char *)wxGetDefaultPyEncoding();
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_FromCharPtr(result);
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28910 PyObject *resultobj = 0;
28911 wxEventLoop *result = 0 ;
28912
28913 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (wxEventLoop *)new wxEventLoop();
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject *swig_obj[1] ;
28933
28934 if (!args) SWIG_fail;
28935 swig_obj[0] = args;
28936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28939 }
28940 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 delete arg1;
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_Py_Void();
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28956 PyObject *resultobj = 0;
28957 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28958 int result;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28968 }
28969 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (int)(arg1)->Run();
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_From_int(static_cast< int >(result));
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28986 int arg2 = (int) 0 ;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 int val2 ;
28990 int ecode2 = 0 ;
28991 PyObject * obj0 = 0 ;
28992 PyObject * obj1 = 0 ;
28993 char * kwnames[] = {
28994 (char *) "self",(char *) "rc", NULL
28995 };
28996
28997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29001 }
29002 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29003 if (obj1) {
29004 ecode2 = SWIG_AsVal_int(obj1, &val2);
29005 if (!SWIG_IsOK(ecode2)) {
29006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29007 }
29008 arg2 = static_cast< int >(val2);
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 (arg1)->Exit(arg2);
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_Py_Void();
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *resultobj = 0;
29025 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29026 bool result;
29027 void *argp1 = 0 ;
29028 int res1 = 0 ;
29029 PyObject *swig_obj[1] ;
29030
29031 if (!args) SWIG_fail;
29032 swig_obj[0] = args;
29033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29036 }
29037 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (bool)((wxEventLoop const *)arg1)->Pending();
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 {
29045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29046 }
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *resultobj = 0;
29055 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29056 bool result;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject *swig_obj[1] ;
29060
29061 if (!args) SWIG_fail;
29062 swig_obj[0] = args;
29063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29064 if (!SWIG_IsOK(res1)) {
29065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29066 }
29067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (bool)(arg1)->Dispatch();
29071 wxPyEndAllowThreads(__tstate);
29072 if (PyErr_Occurred()) SWIG_fail;
29073 }
29074 {
29075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29076 }
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29086 bool result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29096 }
29097 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 {
29105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29106 }
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29114 PyObject *resultobj = 0;
29115 wxEventLoop *result = 0 ;
29116
29117 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29118 {
29119 PyThreadState* __tstate = wxPyBeginAllowThreads();
29120 result = (wxEventLoop *)wxEventLoop::GetActive();
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = 0;
29133 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 PyObject * obj0 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "loop", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29143 if (!SWIG_IsOK(res1)) {
29144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29145 }
29146 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 wxEventLoop::SetActive(arg1);
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_Py_Void();
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29161 PyObject *obj;
29162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29163 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29164 return SWIG_Py_Void();
29165 }
29166
29167 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 return SWIG_Python_InitShadowInstance(args);
29169 }
29170
29171 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj = 0;
29173 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29174 wxEventLoopActivator *result = 0 ;
29175 void *argp1 = 0 ;
29176 int res1 = 0 ;
29177 PyObject * obj0 = 0 ;
29178 char * kwnames[] = {
29179 (char *) "evtLoop", NULL
29180 };
29181
29182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29184 if (!SWIG_IsOK(res1)) {
29185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29186 }
29187 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29202 PyObject *resultobj = 0;
29203 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29204 void *argp1 = 0 ;
29205 int res1 = 0 ;
29206 PyObject *swig_obj[1] ;
29207
29208 if (!args) SWIG_fail;
29209 swig_obj[0] = args;
29210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29213 }
29214 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 delete arg1;
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_Py_Void();
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 PyObject *obj;
29231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29232 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29233 return SWIG_Py_Void();
29234 }
29235
29236 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29237 return SWIG_Python_InitShadowInstance(args);
29238 }
29239
29240 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29241 PyObject *resultobj = 0;
29242 int arg1 = (int) 0 ;
29243 int arg2 = (int) 0 ;
29244 int arg3 = (int) 0 ;
29245 wxAcceleratorEntry *result = 0 ;
29246 int val1 ;
29247 int ecode1 = 0 ;
29248 int val2 ;
29249 int ecode2 = 0 ;
29250 int val3 ;
29251 int ecode3 = 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29260 if (obj0) {
29261 ecode1 = SWIG_AsVal_int(obj0, &val1);
29262 if (!SWIG_IsOK(ecode1)) {
29263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29264 }
29265 arg1 = static_cast< int >(val1);
29266 }
29267 if (obj1) {
29268 ecode2 = SWIG_AsVal_int(obj1, &val2);
29269 if (!SWIG_IsOK(ecode2)) {
29270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29271 }
29272 arg2 = static_cast< int >(val2);
29273 }
29274 if (obj2) {
29275 ecode3 = SWIG_AsVal_int(obj2, &val3);
29276 if (!SWIG_IsOK(ecode3)) {
29277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29278 }
29279 arg3 = static_cast< int >(val3);
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29295 PyObject *resultobj = 0;
29296 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29297 void *argp1 = 0 ;
29298 int res1 = 0 ;
29299 PyObject *swig_obj[1] ;
29300
29301 if (!args) SWIG_fail;
29302 swig_obj[0] = args;
29303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29306 }
29307 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 delete arg1;
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_Py_Void();
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj = 0;
29324 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29325 int arg2 ;
29326 int arg3 ;
29327 int arg4 ;
29328 void *argp1 = 0 ;
29329 int res1 = 0 ;
29330 int val2 ;
29331 int ecode2 = 0 ;
29332 int val3 ;
29333 int ecode3 = 0 ;
29334 int val4 ;
29335 int ecode4 = 0 ;
29336 PyObject * obj0 = 0 ;
29337 PyObject * obj1 = 0 ;
29338 PyObject * obj2 = 0 ;
29339 PyObject * obj3 = 0 ;
29340 char * kwnames[] = {
29341 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29342 };
29343
29344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29346 if (!SWIG_IsOK(res1)) {
29347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29348 }
29349 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29350 ecode2 = SWIG_AsVal_int(obj1, &val2);
29351 if (!SWIG_IsOK(ecode2)) {
29352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29353 }
29354 arg2 = static_cast< int >(val2);
29355 ecode3 = SWIG_AsVal_int(obj2, &val3);
29356 if (!SWIG_IsOK(ecode3)) {
29357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29358 }
29359 arg3 = static_cast< int >(val3);
29360 ecode4 = SWIG_AsVal_int(obj3, &val4);
29361 if (!SWIG_IsOK(ecode4)) {
29362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29363 }
29364 arg4 = static_cast< int >(val4);
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 (arg1)->Set(arg2,arg3,arg4);
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_Py_Void();
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxString *arg1 = 0 ;
29381 wxAcceleratorEntry *result = 0 ;
29382 bool temp1 = false ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "str", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29389 {
29390 arg1 = wxString_in_helper(obj0);
29391 if (arg1 == NULL) SWIG_fail;
29392 temp1 = true;
29393 }
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29401 {
29402 if (temp1)
29403 delete arg1;
29404 }
29405 return resultobj;
29406 fail:
29407 {
29408 if (temp1)
29409 delete arg1;
29410 }
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29418 int result;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29428 }
29429 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (int)(arg1)->GetFlags();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_From_int(static_cast< int >(result));
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29446 int result;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 PyObject *swig_obj[1] ;
29450
29451 if (!args) SWIG_fail;
29452 swig_obj[0] = args;
29453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29456 }
29457 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (int)(arg1)->GetKeyCode();
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 resultobj = SWIG_From_int(static_cast< int >(result));
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29472 PyObject *resultobj = 0;
29473 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29474 int result;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 PyObject *swig_obj[1] ;
29478
29479 if (!args) SWIG_fail;
29480 swig_obj[0] = args;
29481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29482 if (!SWIG_IsOK(res1)) {
29483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29484 }
29485 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 result = (int)(arg1)->GetCommand();
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 resultobj = SWIG_From_int(static_cast< int >(result));
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29500 PyObject *resultobj = 0;
29501 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29502 bool result;
29503 void *argp1 = 0 ;
29504 int res1 = 0 ;
29505 PyObject *swig_obj[1] ;
29506
29507 if (!args) SWIG_fail;
29508 swig_obj[0] = args;
29509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29510 if (!SWIG_IsOK(res1)) {
29511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29512 }
29513 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29532 wxString result;
29533 void *argp1 = 0 ;
29534 int res1 = 0 ;
29535 PyObject *swig_obj[1] ;
29536
29537 if (!args) SWIG_fail;
29538 swig_obj[0] = args;
29539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29542 }
29543 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 #if wxUSE_UNICODE
29552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29553 #else
29554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29555 #endif
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj = 0;
29565 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29566 wxString *arg2 = 0 ;
29567 bool result;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 bool temp2 = false ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char * kwnames[] = {
29574 (char *) "self",(char *) "str", NULL
29575 };
29576
29577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29581 }
29582 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29583 {
29584 arg2 = wxString_in_helper(obj1);
29585 if (arg2 == NULL) SWIG_fail;
29586 temp2 = true;
29587 }
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 {
29595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29596 }
29597 {
29598 if (temp2)
29599 delete arg2;
29600 }
29601 return resultobj;
29602 fail:
29603 {
29604 if (temp2)
29605 delete arg2;
29606 }
29607 return NULL;
29608 }
29609
29610
29611 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 PyObject *obj;
29613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29614 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29615 return SWIG_Py_Void();
29616 }
29617
29618 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29619 return SWIG_Python_InitShadowInstance(args);
29620 }
29621
29622 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj = 0;
29624 int arg1 ;
29625 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29626 wxAcceleratorTable *result = 0 ;
29627 PyObject * obj0 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "n", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29633 {
29634 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29635 if (arg2) arg1 = PyList_Size(obj0);
29636 else arg1 = 0;
29637 }
29638 {
29639 PyThreadState* __tstate = wxPyBeginAllowThreads();
29640 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29654 void *argp1 = 0 ;
29655 int res1 = 0 ;
29656 PyObject *swig_obj[1] ;
29657
29658 if (!args) SWIG_fail;
29659 swig_obj[0] = args;
29660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29661 if (!SWIG_IsOK(res1)) {
29662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29663 }
29664 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29665 {
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 delete arg1;
29668
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 resultobj = SWIG_Py_Void();
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *resultobj = 0;
29681 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 PyObject *swig_obj[1] ;
29686
29687 if (!args) SWIG_fail;
29688 swig_obj[0] = args;
29689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29692 }
29693 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29710 PyObject *obj;
29711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29712 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29713 return SWIG_Py_Void();
29714 }
29715
29716 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29717 return SWIG_Python_InitShadowInstance(args);
29718 }
29719
29720 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29721 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29722 return 1;
29723 }
29724
29725
29726 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29727 PyObject *pyobj = 0;
29728
29729 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29730 return pyobj;
29731 }
29732
29733
29734 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj = 0;
29736 wxString *arg1 = 0 ;
29737 wxAcceleratorEntry *result = 0 ;
29738 bool temp1 = false ;
29739 PyObject * obj0 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "label", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29745 {
29746 arg1 = wxString_in_helper(obj0);
29747 if (arg1 == NULL) SWIG_fail;
29748 temp1 = true;
29749 }
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29757 {
29758 if (temp1)
29759 delete arg1;
29760 }
29761 return resultobj;
29762 fail:
29763 {
29764 if (temp1)
29765 delete arg1;
29766 }
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN int PanelNameStr_set(PyObject *) {
29772 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29773 return 1;
29774 }
29775
29776
29777 SWIGINTERN PyObject *PanelNameStr_get(void) {
29778 PyObject *pyobj = 0;
29779
29780 {
29781 #if wxUSE_UNICODE
29782 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29783 #else
29784 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29785 #endif
29786 }
29787 return pyobj;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29792 PyObject *resultobj = 0;
29793 wxVisualAttributes *result = 0 ;
29794
29795 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxVisualAttributes *)new_wxVisualAttributes();
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 PyObject *swig_obj[1] ;
29815
29816 if (!args) SWIG_fail;
29817 swig_obj[0] = args;
29818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29821 }
29822 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 delete_wxVisualAttributes(arg1);
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 resultobj = SWIG_Py_Void();
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29838 PyObject *resultobj = 0;
29839 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29840 wxFont *arg2 = (wxFont *) 0 ;
29841 void *argp1 = 0 ;
29842 int res1 = 0 ;
29843 void *argp2 = 0 ;
29844 int res2 = 0 ;
29845 PyObject *swig_obj[2] ;
29846
29847 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29851 }
29852 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29853 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29854 if (!SWIG_IsOK(res2)) {
29855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29856 }
29857 arg2 = reinterpret_cast< wxFont * >(argp2);
29858 if (arg1) (arg1)->font = *arg2;
29859
29860 resultobj = SWIG_Py_Void();
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *resultobj = 0;
29869 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29870 wxFont *result = 0 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 PyObject *swig_obj[1] ;
29874
29875 if (!args) SWIG_fail;
29876 swig_obj[0] = args;
29877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29880 }
29881 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29882 result = (wxFont *)& ((arg1)->font);
29883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29893 wxColour *arg2 = (wxColour *) 0 ;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 void *argp2 = 0 ;
29897 int res2 = 0 ;
29898 PyObject *swig_obj[2] ;
29899
29900 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29904 }
29905 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29906 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29909 }
29910 arg2 = reinterpret_cast< wxColour * >(argp2);
29911 if (arg1) (arg1)->colFg = *arg2;
29912
29913 resultobj = SWIG_Py_Void();
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29921 PyObject *resultobj = 0;
29922 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29923 wxColour *result = 0 ;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 PyObject *swig_obj[1] ;
29927
29928 if (!args) SWIG_fail;
29929 swig_obj[0] = args;
29930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29933 }
29934 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29935 result = (wxColour *)& ((arg1)->colFg);
29936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29944 PyObject *resultobj = 0;
29945 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29946 wxColour *arg2 = (wxColour *) 0 ;
29947 void *argp1 = 0 ;
29948 int res1 = 0 ;
29949 void *argp2 = 0 ;
29950 int res2 = 0 ;
29951 PyObject *swig_obj[2] ;
29952
29953 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29957 }
29958 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29959 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29962 }
29963 arg2 = reinterpret_cast< wxColour * >(argp2);
29964 if (arg1) (arg1)->colBg = *arg2;
29965
29966 resultobj = SWIG_Py_Void();
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29976 wxColour *result = 0 ;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29986 }
29987 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29988 result = (wxColour *)& ((arg1)->colBg);
29989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 int arg2 = (int) (int)-1 ;
30011 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30012 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30013 wxSize const &arg4_defvalue = wxDefaultSize ;
30014 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30015 long arg5 = (long) 0 ;
30016 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30017 wxString *arg6 = (wxString *) &arg6_defvalue ;
30018 wxWindow *result = 0 ;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 int val2 ;
30022 int ecode2 = 0 ;
30023 wxPoint temp3 ;
30024 wxSize temp4 ;
30025 long val5 ;
30026 int ecode5 = 0 ;
30027 bool temp6 = false ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 PyObject * obj2 = 0 ;
30031 PyObject * obj3 = 0 ;
30032 PyObject * obj4 = 0 ;
30033 PyObject * obj5 = 0 ;
30034 char * kwnames[] = {
30035 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30036 };
30037
30038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 if (obj1) {
30045 ecode2 = SWIG_AsVal_int(obj1, &val2);
30046 if (!SWIG_IsOK(ecode2)) {
30047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30048 }
30049 arg2 = static_cast< int >(val2);
30050 }
30051 if (obj2) {
30052 {
30053 arg3 = &temp3;
30054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30055 }
30056 }
30057 if (obj3) {
30058 {
30059 arg4 = &temp4;
30060 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30061 }
30062 }
30063 if (obj4) {
30064 ecode5 = SWIG_AsVal_long(obj4, &val5);
30065 if (!SWIG_IsOK(ecode5)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30067 }
30068 arg5 = static_cast< long >(val5);
30069 }
30070 if (obj5) {
30071 {
30072 arg6 = wxString_in_helper(obj5);
30073 if (arg6 == NULL) SWIG_fail;
30074 temp6 = true;
30075 }
30076 }
30077 {
30078 if (!wxPyCheckForApp()) SWIG_fail;
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30085 {
30086 if (temp6)
30087 delete arg6;
30088 }
30089 return resultobj;
30090 fail:
30091 {
30092 if (temp6)
30093 delete arg6;
30094 }
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxWindow *result = 0 ;
30102
30103 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30104 {
30105 if (!wxPyCheckForApp()) SWIG_fail;
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (wxWindow *)new wxWindow();
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxWindow *arg2 = (wxWindow *) 0 ;
30122 int arg3 = (int) (int)-1 ;
30123 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30124 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30125 wxSize const &arg5_defvalue = wxDefaultSize ;
30126 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30127 long arg6 = (long) 0 ;
30128 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30129 wxString *arg7 = (wxString *) &arg7_defvalue ;
30130 bool result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 void *argp2 = 0 ;
30134 int res2 = 0 ;
30135 int val3 ;
30136 int ecode3 = 0 ;
30137 wxPoint temp4 ;
30138 wxSize temp5 ;
30139 long val6 ;
30140 int ecode6 = 0 ;
30141 bool temp7 = false ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 PyObject * obj2 = 0 ;
30145 PyObject * obj3 = 0 ;
30146 PyObject * obj4 = 0 ;
30147 PyObject * obj5 = 0 ;
30148 PyObject * obj6 = 0 ;
30149 char * kwnames[] = {
30150 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30151 };
30152
30153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30157 }
30158 arg1 = reinterpret_cast< wxWindow * >(argp1);
30159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30160 if (!SWIG_IsOK(res2)) {
30161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30162 }
30163 arg2 = reinterpret_cast< wxWindow * >(argp2);
30164 if (obj2) {
30165 ecode3 = SWIG_AsVal_int(obj2, &val3);
30166 if (!SWIG_IsOK(ecode3)) {
30167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30168 }
30169 arg3 = static_cast< int >(val3);
30170 }
30171 if (obj3) {
30172 {
30173 arg4 = &temp4;
30174 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30175 }
30176 }
30177 if (obj4) {
30178 {
30179 arg5 = &temp5;
30180 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30181 }
30182 }
30183 if (obj5) {
30184 ecode6 = SWIG_AsVal_long(obj5, &val6);
30185 if (!SWIG_IsOK(ecode6)) {
30186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30187 }
30188 arg6 = static_cast< long >(val6);
30189 }
30190 if (obj6) {
30191 {
30192 arg7 = wxString_in_helper(obj6);
30193 if (arg7 == NULL) SWIG_fail;
30194 temp7 = true;
30195 }
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 {
30204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30205 }
30206 {
30207 if (temp7)
30208 delete arg7;
30209 }
30210 return resultobj;
30211 fail:
30212 {
30213 if (temp7)
30214 delete arg7;
30215 }
30216 return NULL;
30217 }
30218
30219
30220 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj = 0;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 bool arg2 = (bool) false ;
30224 bool result;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 bool val2 ;
30228 int ecode2 = 0 ;
30229 PyObject * obj0 = 0 ;
30230 PyObject * obj1 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "self",(char *) "force", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30237 if (!SWIG_IsOK(res1)) {
30238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30239 }
30240 arg1 = reinterpret_cast< wxWindow * >(argp1);
30241 if (obj1) {
30242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30243 if (!SWIG_IsOK(ecode2)) {
30244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30245 }
30246 arg2 = static_cast< bool >(val2);
30247 }
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (bool)(arg1)->Close(arg2);
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30264 PyObject *resultobj = 0;
30265 wxWindow *arg1 = (wxWindow *) 0 ;
30266 bool result;
30267 void *argp1 = 0 ;
30268 int res1 = 0 ;
30269 PyObject *swig_obj[1] ;
30270
30271 if (!args) SWIG_fail;
30272 swig_obj[0] = args;
30273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30274 if (!SWIG_IsOK(res1)) {
30275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30276 }
30277 arg1 = reinterpret_cast< wxWindow * >(argp1);
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 result = (bool)(arg1)->Destroy();
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 {
30285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30286 }
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 wxWindow *arg1 = (wxWindow *) 0 ;
30296 bool result;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 PyObject *swig_obj[1] ;
30300
30301 if (!args) SWIG_fail;
30302 swig_obj[0] = args;
30303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 {
30309 PyThreadState* __tstate = wxPyBeginAllowThreads();
30310 result = (bool)(arg1)->DestroyChildren();
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 {
30315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30316 }
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30324 PyObject *resultobj = 0;
30325 wxWindow *arg1 = (wxWindow *) 0 ;
30326 bool result;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject *swig_obj[1] ;
30330
30331 if (!args) SWIG_fail;
30332 swig_obj[0] = args;
30333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30334 if (!SWIG_IsOK(res1)) {
30335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30336 }
30337 arg1 = reinterpret_cast< wxWindow * >(argp1);
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 {
30345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30346 }
30347 return resultobj;
30348 fail:
30349 return NULL;
30350 }
30351
30352
30353 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj = 0;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 wxString *arg2 = 0 ;
30357 void *argp1 = 0 ;
30358 int res1 = 0 ;
30359 bool temp2 = false ;
30360 PyObject * obj0 = 0 ;
30361 PyObject * obj1 = 0 ;
30362 char * kwnames[] = {
30363 (char *) "self",(char *) "label", NULL
30364 };
30365
30366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30368 if (!SWIG_IsOK(res1)) {
30369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30370 }
30371 arg1 = reinterpret_cast< wxWindow * >(argp1);
30372 {
30373 arg2 = wxString_in_helper(obj1);
30374 if (arg2 == NULL) SWIG_fail;
30375 temp2 = true;
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->SetLabel((wxString const &)*arg2);
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 {
30385 if (temp2)
30386 delete arg2;
30387 }
30388 return resultobj;
30389 fail:
30390 {
30391 if (temp2)
30392 delete arg2;
30393 }
30394 return NULL;
30395 }
30396
30397
30398 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30399 PyObject *resultobj = 0;
30400 wxWindow *arg1 = (wxWindow *) 0 ;
30401 wxString result;
30402 void *argp1 = 0 ;
30403 int res1 = 0 ;
30404 PyObject *swig_obj[1] ;
30405
30406 if (!args) SWIG_fail;
30407 swig_obj[0] = args;
30408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30409 if (!SWIG_IsOK(res1)) {
30410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30411 }
30412 arg1 = reinterpret_cast< wxWindow * >(argp1);
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = ((wxWindow const *)arg1)->GetLabel();
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 {
30420 #if wxUSE_UNICODE
30421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30422 #else
30423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30424 #endif
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj = 0;
30434 wxWindow *arg1 = (wxWindow *) 0 ;
30435 wxString *arg2 = 0 ;
30436 void *argp1 = 0 ;
30437 int res1 = 0 ;
30438 bool temp2 = false ;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "name", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 {
30452 arg2 = wxString_in_helper(obj1);
30453 if (arg2 == NULL) SWIG_fail;
30454 temp2 = true;
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetName((wxString const &)*arg2);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_Py_Void();
30463 {
30464 if (temp2)
30465 delete arg2;
30466 }
30467 return resultobj;
30468 fail:
30469 {
30470 if (temp2)
30471 delete arg2;
30472 }
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxWindow *arg1 = (wxWindow *) 0 ;
30480 wxString result;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 PyObject *swig_obj[1] ;
30484
30485 if (!args) SWIG_fail;
30486 swig_obj[0] = args;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30490 }
30491 arg1 = reinterpret_cast< wxWindow * >(argp1);
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 result = ((wxWindow const *)arg1)->GetName();
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 {
30499 #if wxUSE_UNICODE
30500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30501 #else
30502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30503 #endif
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj = 0;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 wxWindowVariant arg2 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 int val2 ;
30518 int ecode2 = 0 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char * kwnames[] = {
30522 (char *) "self",(char *) "variant", NULL
30523 };
30524
30525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30529 }
30530 arg1 = reinterpret_cast< wxWindow * >(argp1);
30531 ecode2 = SWIG_AsVal_int(obj1, &val2);
30532 if (!SWIG_IsOK(ecode2)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30534 }
30535 arg2 = static_cast< wxWindowVariant >(val2);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetWindowVariant(arg2);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_Py_Void();
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30550 PyObject *resultobj = 0;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxWindowVariant result;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 PyObject *swig_obj[1] ;
30556
30557 if (!args) SWIG_fail;
30558 swig_obj[0] = args;
30559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 resultobj = SWIG_From_int(static_cast< int >(result));
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj = 0;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 int arg2 ;
30581 void *argp1 = 0 ;
30582 int res1 = 0 ;
30583 int val2 ;
30584 int ecode2 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 char * kwnames[] = {
30588 (char *) "self",(char *) "winid", NULL
30589 };
30590
30591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30595 }
30596 arg1 = reinterpret_cast< wxWindow * >(argp1);
30597 ecode2 = SWIG_AsVal_int(obj1, &val2);
30598 if (!SWIG_IsOK(ecode2)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30600 }
30601 arg2 = static_cast< int >(val2);
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 (arg1)->SetId(arg2);
30605 wxPyEndAllowThreads(__tstate);
30606 if (PyErr_Occurred()) SWIG_fail;
30607 }
30608 resultobj = SWIG_Py_Void();
30609 return resultobj;
30610 fail:
30611 return NULL;
30612 }
30613
30614
30615 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30616 PyObject *resultobj = 0;
30617 wxWindow *arg1 = (wxWindow *) 0 ;
30618 int result;
30619 void *argp1 = 0 ;
30620 int res1 = 0 ;
30621 PyObject *swig_obj[1] ;
30622
30623 if (!args) SWIG_fail;
30624 swig_obj[0] = args;
30625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30626 if (!SWIG_IsOK(res1)) {
30627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30628 }
30629 arg1 = reinterpret_cast< wxWindow * >(argp1);
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 result = (int)((wxWindow const *)arg1)->GetId();
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 resultobj = SWIG_From_int(static_cast< int >(result));
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 int result;
30646
30647 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (int)wxWindow::NewControlId();
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_From_int(static_cast< int >(result));
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 int arg1 ;
30664 int result;
30665 int val1 ;
30666 int ecode1 = 0 ;
30667 PyObject * obj0 = 0 ;
30668 char * kwnames[] = {
30669 (char *) "winid", NULL
30670 };
30671
30672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30673 ecode1 = SWIG_AsVal_int(obj0, &val1);
30674 if (!SWIG_IsOK(ecode1)) {
30675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30676 }
30677 arg1 = static_cast< int >(val1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 result = (int)wxWindow::NextControlId(arg1);
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 resultobj = SWIG_From_int(static_cast< int >(result));
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj = 0;
30693 int arg1 ;
30694 int result;
30695 int val1 ;
30696 int ecode1 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "winid", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30703 ecode1 = SWIG_AsVal_int(obj0, &val1);
30704 if (!SWIG_IsOK(ecode1)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30706 }
30707 arg1 = static_cast< int >(val1);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (int)wxWindow::PrevControlId(arg1);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_From_int(static_cast< int >(result));
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30722 PyObject *resultobj = 0;
30723 wxWindow *arg1 = (wxWindow *) 0 ;
30724 wxLayoutDirection result;
30725 void *argp1 = 0 ;
30726 int res1 = 0 ;
30727 PyObject *swig_obj[1] ;
30728
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = ((wxWindow const *)arg1)->GetLayoutDirection();
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj = 0;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 wxLayoutDirection arg2 ;
30753 void *argp1 = 0 ;
30754 int res1 = 0 ;
30755 void *argp2 ;
30756 int res2 = 0 ;
30757 PyObject * obj0 = 0 ;
30758 PyObject * obj1 = 0 ;
30759 char * kwnames[] = {
30760 (char *) "self",(char *) "dir", NULL
30761 };
30762
30763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30767 }
30768 arg1 = reinterpret_cast< wxWindow * >(argp1);
30769 {
30770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxLayoutDirection, 0 | 0);
30771 if (!SWIG_IsOK(res2)) {
30772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30773 }
30774 if (!argp2) {
30775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30776 } else {
30777 wxLayoutDirection * temp = reinterpret_cast< wxLayoutDirection * >(argp2);
30778 arg2 = *temp;
30779 if (SWIG_IsNewObj(res2)) delete temp;
30780 }
30781 }
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 (arg1)->SetLayoutDirection(arg2);
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 resultobj = SWIG_Py_Void();
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj = 0;
30797 wxWindow *arg1 = (wxWindow *) 0 ;
30798 int arg2 ;
30799 int arg3 ;
30800 int arg4 ;
30801 int result;
30802 void *argp1 = 0 ;
30803 int res1 = 0 ;
30804 int val2 ;
30805 int ecode2 = 0 ;
30806 int val3 ;
30807 int ecode3 = 0 ;
30808 int val4 ;
30809 int ecode4 = 0 ;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 PyObject * obj2 = 0 ;
30813 PyObject * obj3 = 0 ;
30814 char * kwnames[] = {
30815 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30816 };
30817
30818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30822 }
30823 arg1 = reinterpret_cast< wxWindow * >(argp1);
30824 ecode2 = SWIG_AsVal_int(obj1, &val2);
30825 if (!SWIG_IsOK(ecode2)) {
30826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30827 }
30828 arg2 = static_cast< int >(val2);
30829 ecode3 = SWIG_AsVal_int(obj2, &val3);
30830 if (!SWIG_IsOK(ecode3)) {
30831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30832 }
30833 arg3 = static_cast< int >(val3);
30834 ecode4 = SWIG_AsVal_int(obj3, &val4);
30835 if (!SWIG_IsOK(ecode4)) {
30836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30837 }
30838 arg4 = static_cast< int >(val4);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 resultobj = SWIG_From_int(static_cast< int >(result));
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj = 0;
30854 wxWindow *arg1 = (wxWindow *) 0 ;
30855 wxSize *arg2 = 0 ;
30856 void *argp1 = 0 ;
30857 int res1 = 0 ;
30858 wxSize temp2 ;
30859 PyObject * obj0 = 0 ;
30860 PyObject * obj1 = 0 ;
30861 char * kwnames[] = {
30862 (char *) "self",(char *) "size", NULL
30863 };
30864
30865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30869 }
30870 arg1 = reinterpret_cast< wxWindow * >(argp1);
30871 {
30872 arg2 = &temp2;
30873 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 (arg1)->SetSize((wxSize const &)*arg2);
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 resultobj = SWIG_Py_Void();
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj = 0;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 int arg2 ;
30892 int arg3 ;
30893 int arg4 ;
30894 int arg5 ;
30895 int arg6 = (int) wxSIZE_AUTO ;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 int val2 ;
30899 int ecode2 = 0 ;
30900 int val3 ;
30901 int ecode3 = 0 ;
30902 int val4 ;
30903 int ecode4 = 0 ;
30904 int val5 ;
30905 int ecode5 = 0 ;
30906 int val6 ;
30907 int ecode6 = 0 ;
30908 PyObject * obj0 = 0 ;
30909 PyObject * obj1 = 0 ;
30910 PyObject * obj2 = 0 ;
30911 PyObject * obj3 = 0 ;
30912 PyObject * obj4 = 0 ;
30913 PyObject * obj5 = 0 ;
30914 char * kwnames[] = {
30915 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30916 };
30917
30918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 ecode2 = SWIG_AsVal_int(obj1, &val2);
30925 if (!SWIG_IsOK(ecode2)) {
30926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30927 }
30928 arg2 = static_cast< int >(val2);
30929 ecode3 = SWIG_AsVal_int(obj2, &val3);
30930 if (!SWIG_IsOK(ecode3)) {
30931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30932 }
30933 arg3 = static_cast< int >(val3);
30934 ecode4 = SWIG_AsVal_int(obj3, &val4);
30935 if (!SWIG_IsOK(ecode4)) {
30936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30937 }
30938 arg4 = static_cast< int >(val4);
30939 ecode5 = SWIG_AsVal_int(obj4, &val5);
30940 if (!SWIG_IsOK(ecode5)) {
30941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30942 }
30943 arg5 = static_cast< int >(val5);
30944 if (obj5) {
30945 ecode6 = SWIG_AsVal_int(obj5, &val6);
30946 if (!SWIG_IsOK(ecode6)) {
30947 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30948 }
30949 arg6 = static_cast< int >(val6);
30950 }
30951 {
30952 PyThreadState* __tstate = wxPyBeginAllowThreads();
30953 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 resultobj = SWIG_Py_Void();
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj = 0;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 wxRect *arg2 = 0 ;
30968 int arg3 = (int) wxSIZE_AUTO ;
30969 void *argp1 = 0 ;
30970 int res1 = 0 ;
30971 wxRect temp2 ;
30972 int val3 ;
30973 int ecode3 = 0 ;
30974 PyObject * obj0 = 0 ;
30975 PyObject * obj1 = 0 ;
30976 PyObject * obj2 = 0 ;
30977 char * kwnames[] = {
30978 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30979 };
30980
30981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 {
30988 arg2 = &temp2;
30989 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30990 }
30991 if (obj2) {
30992 ecode3 = SWIG_AsVal_int(obj2, &val3);
30993 if (!SWIG_IsOK(ecode3)) {
30994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30995 }
30996 arg3 = static_cast< int >(val3);
30997 }
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31001 wxPyEndAllowThreads(__tstate);
31002 if (PyErr_Occurred()) SWIG_fail;
31003 }
31004 resultobj = SWIG_Py_Void();
31005 return resultobj;
31006 fail:
31007 return NULL;
31008 }
31009
31010
31011 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31012 PyObject *resultobj = 0;
31013 wxWindow *arg1 = (wxWindow *) 0 ;
31014 int arg2 ;
31015 int arg3 ;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 int val2 ;
31019 int ecode2 = 0 ;
31020 int val3 ;
31021 int ecode3 = 0 ;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 PyObject * obj2 = 0 ;
31025 char * kwnames[] = {
31026 (char *) "self",(char *) "width",(char *) "height", NULL
31027 };
31028
31029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31033 }
31034 arg1 = reinterpret_cast< wxWindow * >(argp1);
31035 ecode2 = SWIG_AsVal_int(obj1, &val2);
31036 if (!SWIG_IsOK(ecode2)) {
31037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31038 }
31039 arg2 = static_cast< int >(val2);
31040 ecode3 = SWIG_AsVal_int(obj2, &val3);
31041 if (!SWIG_IsOK(ecode3)) {
31042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31043 }
31044 arg3 = static_cast< int >(val3);
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 (arg1)->SetSize(arg2,arg3);
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_Py_Void();
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj = 0;
31060 wxWindow *arg1 = (wxWindow *) 0 ;
31061 wxPoint *arg2 = 0 ;
31062 int arg3 = (int) wxSIZE_USE_EXISTING ;
31063 void *argp1 = 0 ;
31064 int res1 = 0 ;
31065 wxPoint temp2 ;
31066 int val3 ;
31067 int ecode3 = 0 ;
31068 PyObject * obj0 = 0 ;
31069 PyObject * obj1 = 0 ;
31070 PyObject * obj2 = 0 ;
31071 char * kwnames[] = {
31072 (char *) "self",(char *) "pt",(char *) "flags", NULL
31073 };
31074
31075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31077 if (!SWIG_IsOK(res1)) {
31078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31079 }
31080 arg1 = reinterpret_cast< wxWindow * >(argp1);
31081 {
31082 arg2 = &temp2;
31083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31084 }
31085 if (obj2) {
31086 ecode3 = SWIG_AsVal_int(obj2, &val3);
31087 if (!SWIG_IsOK(ecode3)) {
31088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31089 }
31090 arg3 = static_cast< int >(val3);
31091 }
31092 {
31093 PyThreadState* __tstate = wxPyBeginAllowThreads();
31094 (arg1)->Move((wxPoint const &)*arg2,arg3);
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 resultobj = SWIG_Py_Void();
31099 return resultobj;
31100 fail:
31101 return NULL;
31102 }
31103
31104
31105 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31106 PyObject *resultobj = 0;
31107 wxWindow *arg1 = (wxWindow *) 0 ;
31108 int arg2 ;
31109 int arg3 ;
31110 int arg4 = (int) wxSIZE_USE_EXISTING ;
31111 void *argp1 = 0 ;
31112 int res1 = 0 ;
31113 int val2 ;
31114 int ecode2 = 0 ;
31115 int val3 ;
31116 int ecode3 = 0 ;
31117 int val4 ;
31118 int ecode4 = 0 ;
31119 PyObject * obj0 = 0 ;
31120 PyObject * obj1 = 0 ;
31121 PyObject * obj2 = 0 ;
31122 PyObject * obj3 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31131 }
31132 arg1 = reinterpret_cast< wxWindow * >(argp1);
31133 ecode2 = SWIG_AsVal_int(obj1, &val2);
31134 if (!SWIG_IsOK(ecode2)) {
31135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31136 }
31137 arg2 = static_cast< int >(val2);
31138 ecode3 = SWIG_AsVal_int(obj2, &val3);
31139 if (!SWIG_IsOK(ecode3)) {
31140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31141 }
31142 arg3 = static_cast< int >(val3);
31143 if (obj3) {
31144 ecode4 = SWIG_AsVal_int(obj3, &val4);
31145 if (!SWIG_IsOK(ecode4)) {
31146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31147 }
31148 arg4 = static_cast< int >(val4);
31149 }
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 (arg1)->Move(arg2,arg3,arg4);
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 resultobj = SWIG_Py_Void();
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 wxSize const &arg2_defvalue = wxDefaultSize ;
31167 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 wxSize temp2 ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "self",(char *) "size", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31181 }
31182 arg1 = reinterpret_cast< wxWindow * >(argp1);
31183 if (obj1) {
31184 {
31185 arg2 = &temp2;
31186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31187 }
31188 }
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 resultobj = SWIG_Py_Void();
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31203 PyObject *resultobj = 0;
31204 wxWindow *arg1 = (wxWindow *) 0 ;
31205 void *argp1 = 0 ;
31206 int res1 = 0 ;
31207 PyObject *swig_obj[1] ;
31208
31209 if (!args) SWIG_fail;
31210 swig_obj[0] = args;
31211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31212 if (!SWIG_IsOK(res1)) {
31213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31214 }
31215 arg1 = reinterpret_cast< wxWindow * >(argp1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 (arg1)->Raise();
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_Py_Void();
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31230 PyObject *resultobj = 0;
31231 wxWindow *arg1 = (wxWindow *) 0 ;
31232 void *argp1 = 0 ;
31233 int res1 = 0 ;
31234 PyObject *swig_obj[1] ;
31235
31236 if (!args) SWIG_fail;
31237 swig_obj[0] = args;
31238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31239 if (!SWIG_IsOK(res1)) {
31240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31241 }
31242 arg1 = reinterpret_cast< wxWindow * >(argp1);
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 (arg1)->Lower();
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_Py_Void();
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31257 PyObject *resultobj = 0;
31258 wxWindow *arg1 = (wxWindow *) 0 ;
31259 wxSize *arg2 = 0 ;
31260 void *argp1 = 0 ;
31261 int res1 = 0 ;
31262 wxSize temp2 ;
31263 PyObject * obj0 = 0 ;
31264 PyObject * obj1 = 0 ;
31265 char * kwnames[] = {
31266 (char *) "self",(char *) "size", NULL
31267 };
31268
31269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31271 if (!SWIG_IsOK(res1)) {
31272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31273 }
31274 arg1 = reinterpret_cast< wxWindow * >(argp1);
31275 {
31276 arg2 = &temp2;
31277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31278 }
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->SetClientSize((wxSize const &)*arg2);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_Py_Void();
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 int arg2 ;
31296 int arg3 ;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 int val2 ;
31300 int ecode2 = 0 ;
31301 int val3 ;
31302 int ecode3 = 0 ;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 PyObject * obj2 = 0 ;
31306 char * kwnames[] = {
31307 (char *) "self",(char *) "width",(char *) "height", NULL
31308 };
31309
31310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31312 if (!SWIG_IsOK(res1)) {
31313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31314 }
31315 arg1 = reinterpret_cast< wxWindow * >(argp1);
31316 ecode2 = SWIG_AsVal_int(obj1, &val2);
31317 if (!SWIG_IsOK(ecode2)) {
31318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31319 }
31320 arg2 = static_cast< int >(val2);
31321 ecode3 = SWIG_AsVal_int(obj2, &val3);
31322 if (!SWIG_IsOK(ecode3)) {
31323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31324 }
31325 arg3 = static_cast< int >(val3);
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 (arg1)->SetClientSize(arg2,arg3);
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 resultobj = SWIG_Py_Void();
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxWindow *arg1 = (wxWindow *) 0 ;
31342 wxRect *arg2 = 0 ;
31343 void *argp1 = 0 ;
31344 int res1 = 0 ;
31345 wxRect temp2 ;
31346 PyObject * obj0 = 0 ;
31347 PyObject * obj1 = 0 ;
31348 char * kwnames[] = {
31349 (char *) "self",(char *) "rect", NULL
31350 };
31351
31352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31354 if (!SWIG_IsOK(res1)) {
31355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31356 }
31357 arg1 = reinterpret_cast< wxWindow * >(argp1);
31358 {
31359 arg2 = &temp2;
31360 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31361 }
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 (arg1)->SetClientSize((wxRect const &)*arg2);
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = SWIG_Py_Void();
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 PyObject *resultobj = 0;
31377 wxWindow *arg1 = (wxWindow *) 0 ;
31378 wxPoint result;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject *swig_obj[1] ;
31382
31383 if (!args) SWIG_fail;
31384 swig_obj[0] = args;
31385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31386 if (!SWIG_IsOK(res1)) {
31387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31388 }
31389 arg1 = reinterpret_cast< wxWindow * >(argp1);
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = ((wxWindow const *)arg1)->GetPosition();
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31404 PyObject *resultobj = 0;
31405 wxWindow *arg1 = (wxWindow *) 0 ;
31406 int *arg2 = (int *) 0 ;
31407 int *arg3 = (int *) 0 ;
31408 void *argp1 = 0 ;
31409 int res1 = 0 ;
31410 int temp2 ;
31411 int res2 = SWIG_TMPOBJ ;
31412 int temp3 ;
31413 int res3 = SWIG_TMPOBJ ;
31414 PyObject *swig_obj[1] ;
31415
31416 arg2 = &temp2;
31417 arg3 = &temp3;
31418 if (!args) SWIG_fail;
31419 swig_obj[0] = args;
31420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31421 if (!SWIG_IsOK(res1)) {
31422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31423 }
31424 arg1 = reinterpret_cast< wxWindow * >(argp1);
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 resultobj = SWIG_Py_Void();
31432 if (SWIG_IsTmpObj(res2)) {
31433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31434 } else {
31435 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31437 }
31438 if (SWIG_IsTmpObj(res3)) {
31439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31440 } else {
31441 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31451 PyObject *resultobj = 0;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 wxPoint result;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 PyObject *swig_obj[1] ;
31457
31458 if (!args) SWIG_fail;
31459 swig_obj[0] = args;
31460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31461 if (!SWIG_IsOK(res1)) {
31462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31463 }
31464 arg1 = reinterpret_cast< wxWindow * >(argp1);
31465 {
31466 PyThreadState* __tstate = wxPyBeginAllowThreads();
31467 result = ((wxWindow const *)arg1)->GetScreenPosition();
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31479 PyObject *resultobj = 0;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 int *arg2 = (int *) 0 ;
31482 int *arg3 = (int *) 0 ;
31483 void *argp1 = 0 ;
31484 int res1 = 0 ;
31485 int temp2 ;
31486 int res2 = SWIG_TMPOBJ ;
31487 int temp3 ;
31488 int res3 = SWIG_TMPOBJ ;
31489 PyObject *swig_obj[1] ;
31490
31491 arg2 = &temp2;
31492 arg3 = &temp3;
31493 if (!args) SWIG_fail;
31494 swig_obj[0] = args;
31495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31496 if (!SWIG_IsOK(res1)) {
31497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31498 }
31499 arg1 = reinterpret_cast< wxWindow * >(argp1);
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 resultobj = SWIG_Py_Void();
31507 if (SWIG_IsTmpObj(res2)) {
31508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31509 } else {
31510 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31512 }
31513 if (SWIG_IsTmpObj(res3)) {
31514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31515 } else {
31516 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31518 }
31519 return resultobj;
31520 fail:
31521 return NULL;
31522 }
31523
31524
31525 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31526 PyObject *resultobj = 0;
31527 wxWindow *arg1 = (wxWindow *) 0 ;
31528 wxRect result;
31529 void *argp1 = 0 ;
31530 int res1 = 0 ;
31531 PyObject *swig_obj[1] ;
31532
31533 if (!args) SWIG_fail;
31534 swig_obj[0] = args;
31535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31536 if (!SWIG_IsOK(res1)) {
31537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31538 }
31539 arg1 = reinterpret_cast< wxWindow * >(argp1);
31540 {
31541 PyThreadState* __tstate = wxPyBeginAllowThreads();
31542 result = ((wxWindow const *)arg1)->GetScreenRect();
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31554 PyObject *resultobj = 0;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 wxSize result;
31557 void *argp1 = 0 ;
31558 int res1 = 0 ;
31559 PyObject *swig_obj[1] ;
31560
31561 if (!args) SWIG_fail;
31562 swig_obj[0] = args;
31563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31564 if (!SWIG_IsOK(res1)) {
31565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31566 }
31567 arg1 = reinterpret_cast< wxWindow * >(argp1);
31568 {
31569 PyThreadState* __tstate = wxPyBeginAllowThreads();
31570 result = ((wxWindow const *)arg1)->GetSize();
31571 wxPyEndAllowThreads(__tstate);
31572 if (PyErr_Occurred()) SWIG_fail;
31573 }
31574 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31575 return resultobj;
31576 fail:
31577 return NULL;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31582 PyObject *resultobj = 0;
31583 wxWindow *arg1 = (wxWindow *) 0 ;
31584 int *arg2 = (int *) 0 ;
31585 int *arg3 = (int *) 0 ;
31586 void *argp1 = 0 ;
31587 int res1 = 0 ;
31588 int temp2 ;
31589 int res2 = SWIG_TMPOBJ ;
31590 int temp3 ;
31591 int res3 = SWIG_TMPOBJ ;
31592 PyObject *swig_obj[1] ;
31593
31594 arg2 = &temp2;
31595 arg3 = &temp3;
31596 if (!args) SWIG_fail;
31597 swig_obj[0] = args;
31598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31599 if (!SWIG_IsOK(res1)) {
31600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31601 }
31602 arg1 = reinterpret_cast< wxWindow * >(argp1);
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 resultobj = SWIG_Py_Void();
31610 if (SWIG_IsTmpObj(res2)) {
31611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31612 } else {
31613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31615 }
31616 if (SWIG_IsTmpObj(res3)) {
31617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31618 } else {
31619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31621 }
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31629 PyObject *resultobj = 0;
31630 wxWindow *arg1 = (wxWindow *) 0 ;
31631 wxRect result;
31632 void *argp1 = 0 ;
31633 int res1 = 0 ;
31634 PyObject *swig_obj[1] ;
31635
31636 if (!args) SWIG_fail;
31637 swig_obj[0] = args;
31638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31639 if (!SWIG_IsOK(res1)) {
31640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31641 }
31642 arg1 = reinterpret_cast< wxWindow * >(argp1);
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 result = ((wxWindow const *)arg1)->GetRect();
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31657 PyObject *resultobj = 0;
31658 wxWindow *arg1 = (wxWindow *) 0 ;
31659 wxSize result;
31660 void *argp1 = 0 ;
31661 int res1 = 0 ;
31662 PyObject *swig_obj[1] ;
31663
31664 if (!args) SWIG_fail;
31665 swig_obj[0] = args;
31666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31667 if (!SWIG_IsOK(res1)) {
31668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31669 }
31670 arg1 = reinterpret_cast< wxWindow * >(argp1);
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 result = ((wxWindow const *)arg1)->GetClientSize();
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31685 PyObject *resultobj = 0;
31686 wxWindow *arg1 = (wxWindow *) 0 ;
31687 int *arg2 = (int *) 0 ;
31688 int *arg3 = (int *) 0 ;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 int temp2 ;
31692 int res2 = SWIG_TMPOBJ ;
31693 int temp3 ;
31694 int res3 = SWIG_TMPOBJ ;
31695 PyObject *swig_obj[1] ;
31696
31697 arg2 = &temp2;
31698 arg3 = &temp3;
31699 if (!args) SWIG_fail;
31700 swig_obj[0] = args;
31701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31704 }
31705 arg1 = reinterpret_cast< wxWindow * >(argp1);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 resultobj = SWIG_Py_Void();
31713 if (SWIG_IsTmpObj(res2)) {
31714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31715 } else {
31716 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31718 }
31719 if (SWIG_IsTmpObj(res3)) {
31720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31721 } else {
31722 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31724 }
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31732 PyObject *resultobj = 0;
31733 wxWindow *arg1 = (wxWindow *) 0 ;
31734 wxPoint result;
31735 void *argp1 = 0 ;
31736 int res1 = 0 ;
31737 PyObject *swig_obj[1] ;
31738
31739 if (!args) SWIG_fail;
31740 swig_obj[0] = args;
31741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31744 }
31745 arg1 = reinterpret_cast< wxWindow * >(argp1);
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31749 wxPyEndAllowThreads(__tstate);
31750 if (PyErr_Occurred()) SWIG_fail;
31751 }
31752 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31753 return resultobj;
31754 fail:
31755 return NULL;
31756 }
31757
31758
31759 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31760 PyObject *resultobj = 0;
31761 wxWindow *arg1 = (wxWindow *) 0 ;
31762 wxRect result;
31763 void *argp1 = 0 ;
31764 int res1 = 0 ;
31765 PyObject *swig_obj[1] ;
31766
31767 if (!args) SWIG_fail;
31768 swig_obj[0] = args;
31769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31770 if (!SWIG_IsOK(res1)) {
31771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31772 }
31773 arg1 = reinterpret_cast< wxWindow * >(argp1);
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = ((wxWindow const *)arg1)->GetClientRect();
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 wxSize result;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31800 }
31801 arg1 = reinterpret_cast< wxWindow * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = ((wxWindow const *)arg1)->GetBestSize();
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxWindow *arg1 = (wxWindow *) 0 ;
31818 int *arg2 = (int *) 0 ;
31819 int *arg3 = (int *) 0 ;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 int temp2 ;
31823 int res2 = SWIG_TMPOBJ ;
31824 int temp3 ;
31825 int res3 = SWIG_TMPOBJ ;
31826 PyObject *swig_obj[1] ;
31827
31828 arg2 = &temp2;
31829 arg3 = &temp3;
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31835 }
31836 arg1 = reinterpret_cast< wxWindow * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_Py_Void();
31844 if (SWIG_IsTmpObj(res2)) {
31845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31846 } else {
31847 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31849 }
31850 if (SWIG_IsTmpObj(res3)) {
31851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31852 } else {
31853 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31855 }
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31863 PyObject *resultobj = 0;
31864 wxWindow *arg1 = (wxWindow *) 0 ;
31865 void *argp1 = 0 ;
31866 int res1 = 0 ;
31867 PyObject *swig_obj[1] ;
31868
31869 if (!args) SWIG_fail;
31870 swig_obj[0] = args;
31871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31874 }
31875 arg1 = reinterpret_cast< wxWindow * >(argp1);
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->InvalidateBestSize();
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_Py_Void();
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 wxSize *arg2 = 0 ;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 wxSize temp2 ;
31896 PyObject * obj0 = 0 ;
31897 PyObject * obj1 = 0 ;
31898 char * kwnames[] = {
31899 (char *) "self",(char *) "size", NULL
31900 };
31901
31902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31904 if (!SWIG_IsOK(res1)) {
31905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31906 }
31907 arg1 = reinterpret_cast< wxWindow * >(argp1);
31908 {
31909 arg2 = &temp2;
31910 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31911 }
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 PyObject *resultobj = 0;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSize result;
31929 void *argp1 = 0 ;
31930 int res1 = 0 ;
31931 PyObject *swig_obj[1] ;
31932
31933 if (!args) SWIG_fail;
31934 swig_obj[0] = args;
31935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31936 if (!SWIG_IsOK(res1)) {
31937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31938 }
31939 arg1 = reinterpret_cast< wxWindow * >(argp1);
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 PyObject *resultobj = 0;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 wxSize result;
31957 void *argp1 = 0 ;
31958 int res1 = 0 ;
31959 PyObject *swig_obj[1] ;
31960
31961 if (!args) SWIG_fail;
31962 swig_obj[0] = args;
31963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31966 }
31967 arg1 = reinterpret_cast< wxWindow * >(argp1);
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 int arg2 = (int) wxBOTH ;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 int val2 ;
31988 int ecode2 = 0 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 char * kwnames[] = {
31992 (char *) "self",(char *) "direction", NULL
31993 };
31994
31995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 if (obj1) {
32002 ecode2 = SWIG_AsVal_int(obj1, &val2);
32003 if (!SWIG_IsOK(ecode2)) {
32004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32005 }
32006 arg2 = static_cast< int >(val2);
32007 }
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 (arg1)->Center(arg2);
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_Py_Void();
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 int arg2 = (int) wxBOTH ;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 int val2 ;
32028 int ecode2 = 0 ;
32029 PyObject * obj0 = 0 ;
32030 PyObject * obj1 = 0 ;
32031 char * kwnames[] = {
32032 (char *) "self",(char *) "dir", NULL
32033 };
32034
32035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32037 if (!SWIG_IsOK(res1)) {
32038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32039 }
32040 arg1 = reinterpret_cast< wxWindow * >(argp1);
32041 if (obj1) {
32042 ecode2 = SWIG_AsVal_int(obj1, &val2);
32043 if (!SWIG_IsOK(ecode2)) {
32044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32045 }
32046 arg2 = static_cast< int >(val2);
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 (arg1)->CenterOnParent(arg2);
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 resultobj = SWIG_Py_Void();
32055 return resultobj;
32056 fail:
32057 return NULL;
32058 }
32059
32060
32061 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32062 PyObject *resultobj = 0;
32063 wxWindow *arg1 = (wxWindow *) 0 ;
32064 void *argp1 = 0 ;
32065 int res1 = 0 ;
32066 PyObject *swig_obj[1] ;
32067
32068 if (!args) SWIG_fail;
32069 swig_obj[0] = args;
32070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32071 if (!SWIG_IsOK(res1)) {
32072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32073 }
32074 arg1 = reinterpret_cast< wxWindow * >(argp1);
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 (arg1)->Fit();
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxWindow *arg1 = (wxWindow *) 0 ;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 PyObject *swig_obj[1] ;
32094
32095 if (!args) SWIG_fail;
32096 swig_obj[0] = args;
32097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32098 if (!SWIG_IsOK(res1)) {
32099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32100 }
32101 arg1 = reinterpret_cast< wxWindow * >(argp1);
32102 {
32103 PyThreadState* __tstate = wxPyBeginAllowThreads();
32104 (arg1)->FitInside();
32105 wxPyEndAllowThreads(__tstate);
32106 if (PyErr_Occurred()) SWIG_fail;
32107 }
32108 resultobj = SWIG_Py_Void();
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32116 PyObject *resultobj = 0;
32117 wxWindow *arg1 = (wxWindow *) 0 ;
32118 int arg2 ;
32119 int arg3 ;
32120 int arg4 = (int) -1 ;
32121 int arg5 = (int) -1 ;
32122 int arg6 = (int) -1 ;
32123 int arg7 = (int) -1 ;
32124 void *argp1 = 0 ;
32125 int res1 = 0 ;
32126 int val2 ;
32127 int ecode2 = 0 ;
32128 int val3 ;
32129 int ecode3 = 0 ;
32130 int val4 ;
32131 int ecode4 = 0 ;
32132 int val5 ;
32133 int ecode5 = 0 ;
32134 int val6 ;
32135 int ecode6 = 0 ;
32136 int val7 ;
32137 int ecode7 = 0 ;
32138 PyObject * obj0 = 0 ;
32139 PyObject * obj1 = 0 ;
32140 PyObject * obj2 = 0 ;
32141 PyObject * obj3 = 0 ;
32142 PyObject * obj4 = 0 ;
32143 PyObject * obj5 = 0 ;
32144 PyObject * obj6 = 0 ;
32145 char * kwnames[] = {
32146 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32147 };
32148
32149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 ecode2 = SWIG_AsVal_int(obj1, &val2);
32156 if (!SWIG_IsOK(ecode2)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32158 }
32159 arg2 = static_cast< int >(val2);
32160 ecode3 = SWIG_AsVal_int(obj2, &val3);
32161 if (!SWIG_IsOK(ecode3)) {
32162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32163 }
32164 arg3 = static_cast< int >(val3);
32165 if (obj3) {
32166 ecode4 = SWIG_AsVal_int(obj3, &val4);
32167 if (!SWIG_IsOK(ecode4)) {
32168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32169 }
32170 arg4 = static_cast< int >(val4);
32171 }
32172 if (obj4) {
32173 ecode5 = SWIG_AsVal_int(obj4, &val5);
32174 if (!SWIG_IsOK(ecode5)) {
32175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32176 }
32177 arg5 = static_cast< int >(val5);
32178 }
32179 if (obj5) {
32180 ecode6 = SWIG_AsVal_int(obj5, &val6);
32181 if (!SWIG_IsOK(ecode6)) {
32182 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32183 }
32184 arg6 = static_cast< int >(val6);
32185 }
32186 if (obj6) {
32187 ecode7 = SWIG_AsVal_int(obj6, &val7);
32188 if (!SWIG_IsOK(ecode7)) {
32189 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32190 }
32191 arg7 = static_cast< int >(val7);
32192 }
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 resultobj = SWIG_Py_Void();
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 wxSize *arg2 = 0 ;
32210 wxSize const &arg3_defvalue = wxDefaultSize ;
32211 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32212 wxSize const &arg4_defvalue = wxDefaultSize ;
32213 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32214 void *argp1 = 0 ;
32215 int res1 = 0 ;
32216 wxSize temp2 ;
32217 wxSize temp3 ;
32218 wxSize temp4 ;
32219 PyObject * obj0 = 0 ;
32220 PyObject * obj1 = 0 ;
32221 PyObject * obj2 = 0 ;
32222 PyObject * obj3 = 0 ;
32223 char * kwnames[] = {
32224 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32225 };
32226
32227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32231 }
32232 arg1 = reinterpret_cast< wxWindow * >(argp1);
32233 {
32234 arg2 = &temp2;
32235 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32236 }
32237 if (obj2) {
32238 {
32239 arg3 = &temp3;
32240 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32241 }
32242 }
32243 if (obj3) {
32244 {
32245 arg4 = &temp4;
32246 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32247 }
32248 }
32249 {
32250 PyThreadState* __tstate = wxPyBeginAllowThreads();
32251 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32252 wxPyEndAllowThreads(__tstate);
32253 if (PyErr_Occurred()) SWIG_fail;
32254 }
32255 resultobj = SWIG_Py_Void();
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 int arg2 ;
32266 int arg3 ;
32267 int arg4 = (int) -1 ;
32268 int arg5 = (int) -1 ;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 int val2 ;
32272 int ecode2 = 0 ;
32273 int val3 ;
32274 int ecode3 = 0 ;
32275 int val4 ;
32276 int ecode4 = 0 ;
32277 int val5 ;
32278 int ecode5 = 0 ;
32279 PyObject * obj0 = 0 ;
32280 PyObject * obj1 = 0 ;
32281 PyObject * obj2 = 0 ;
32282 PyObject * obj3 = 0 ;
32283 PyObject * obj4 = 0 ;
32284 char * kwnames[] = {
32285 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32286 };
32287
32288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32290 if (!SWIG_IsOK(res1)) {
32291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32292 }
32293 arg1 = reinterpret_cast< wxWindow * >(argp1);
32294 ecode2 = SWIG_AsVal_int(obj1, &val2);
32295 if (!SWIG_IsOK(ecode2)) {
32296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32297 }
32298 arg2 = static_cast< int >(val2);
32299 ecode3 = SWIG_AsVal_int(obj2, &val3);
32300 if (!SWIG_IsOK(ecode3)) {
32301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32302 }
32303 arg3 = static_cast< int >(val3);
32304 if (obj3) {
32305 ecode4 = SWIG_AsVal_int(obj3, &val4);
32306 if (!SWIG_IsOK(ecode4)) {
32307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32308 }
32309 arg4 = static_cast< int >(val4);
32310 }
32311 if (obj4) {
32312 ecode5 = SWIG_AsVal_int(obj4, &val5);
32313 if (!SWIG_IsOK(ecode5)) {
32314 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32315 }
32316 arg5 = static_cast< int >(val5);
32317 }
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 resultobj = SWIG_Py_Void();
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj = 0;
32333 wxWindow *arg1 = (wxWindow *) 0 ;
32334 wxSize *arg2 = 0 ;
32335 wxSize const &arg3_defvalue = wxDefaultSize ;
32336 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 wxSize temp2 ;
32340 wxSize temp3 ;
32341 PyObject * obj0 = 0 ;
32342 PyObject * obj1 = 0 ;
32343 PyObject * obj2 = 0 ;
32344 char * kwnames[] = {
32345 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32346 };
32347
32348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32352 }
32353 arg1 = reinterpret_cast< wxWindow * >(argp1);
32354 {
32355 arg2 = &temp2;
32356 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32357 }
32358 if (obj2) {
32359 {
32360 arg3 = &temp3;
32361 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32362 }
32363 }
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_Py_Void();
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *resultobj = 0;
32379 wxWindow *arg1 = (wxWindow *) 0 ;
32380 wxSize result;
32381 void *argp1 = 0 ;
32382 int res1 = 0 ;
32383 PyObject *swig_obj[1] ;
32384
32385 if (!args) SWIG_fail;
32386 swig_obj[0] = args;
32387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32388 if (!SWIG_IsOK(res1)) {
32389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32390 }
32391 arg1 = reinterpret_cast< wxWindow * >(argp1);
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = ((wxWindow const *)arg1)->GetMaxSize();
32395 wxPyEndAllowThreads(__tstate);
32396 if (PyErr_Occurred()) SWIG_fail;
32397 }
32398 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32399 return resultobj;
32400 fail:
32401 return NULL;
32402 }
32403
32404
32405 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32406 PyObject *resultobj = 0;
32407 wxWindow *arg1 = (wxWindow *) 0 ;
32408 wxSize result;
32409 void *argp1 = 0 ;
32410 int res1 = 0 ;
32411 PyObject *swig_obj[1] ;
32412
32413 if (!args) SWIG_fail;
32414 swig_obj[0] = args;
32415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32416 if (!SWIG_IsOK(res1)) {
32417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32418 }
32419 arg1 = reinterpret_cast< wxWindow * >(argp1);
32420 {
32421 PyThreadState* __tstate = wxPyBeginAllowThreads();
32422 result = ((wxWindow const *)arg1)->GetMinSize();
32423 wxPyEndAllowThreads(__tstate);
32424 if (PyErr_Occurred()) SWIG_fail;
32425 }
32426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32427 return resultobj;
32428 fail:
32429 return NULL;
32430 }
32431
32432
32433 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32434 PyObject *resultobj = 0;
32435 wxWindow *arg1 = (wxWindow *) 0 ;
32436 wxSize *arg2 = 0 ;
32437 void *argp1 = 0 ;
32438 int res1 = 0 ;
32439 wxSize temp2 ;
32440 PyObject * obj0 = 0 ;
32441 PyObject * obj1 = 0 ;
32442 char * kwnames[] = {
32443 (char *) "self",(char *) "minSize", NULL
32444 };
32445
32446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32448 if (!SWIG_IsOK(res1)) {
32449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32450 }
32451 arg1 = reinterpret_cast< wxWindow * >(argp1);
32452 {
32453 arg2 = &temp2;
32454 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32455 }
32456 {
32457 PyThreadState* __tstate = wxPyBeginAllowThreads();
32458 (arg1)->SetMinSize((wxSize const &)*arg2);
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 resultobj = SWIG_Py_Void();
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 wxSize *arg2 = 0 ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 wxSize temp2 ;
32476 PyObject * obj0 = 0 ;
32477 PyObject * obj1 = 0 ;
32478 char * kwnames[] = {
32479 (char *) "self",(char *) "maxSize", NULL
32480 };
32481
32482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32486 }
32487 arg1 = reinterpret_cast< wxWindow * >(argp1);
32488 {
32489 arg2 = &temp2;
32490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32491 }
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 (arg1)->SetMaxSize((wxSize const &)*arg2);
32495 wxPyEndAllowThreads(__tstate);
32496 if (PyErr_Occurred()) SWIG_fail;
32497 }
32498 resultobj = SWIG_Py_Void();
32499 return resultobj;
32500 fail:
32501 return NULL;
32502 }
32503
32504
32505 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32506 PyObject *resultobj = 0;
32507 wxWindow *arg1 = (wxWindow *) 0 ;
32508 int result;
32509 void *argp1 = 0 ;
32510 int res1 = 0 ;
32511 PyObject *swig_obj[1] ;
32512
32513 if (!args) SWIG_fail;
32514 swig_obj[0] = args;
32515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32516 if (!SWIG_IsOK(res1)) {
32517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32518 }
32519 arg1 = reinterpret_cast< wxWindow * >(argp1);
32520 {
32521 PyThreadState* __tstate = wxPyBeginAllowThreads();
32522 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 resultobj = SWIG_From_int(static_cast< int >(result));
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32534 PyObject *resultobj = 0;
32535 wxWindow *arg1 = (wxWindow *) 0 ;
32536 int result;
32537 void *argp1 = 0 ;
32538 int res1 = 0 ;
32539 PyObject *swig_obj[1] ;
32540
32541 if (!args) SWIG_fail;
32542 swig_obj[0] = args;
32543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32544 if (!SWIG_IsOK(res1)) {
32545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32546 }
32547 arg1 = reinterpret_cast< wxWindow * >(argp1);
32548 {
32549 PyThreadState* __tstate = wxPyBeginAllowThreads();
32550 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32551 wxPyEndAllowThreads(__tstate);
32552 if (PyErr_Occurred()) SWIG_fail;
32553 }
32554 resultobj = SWIG_From_int(static_cast< int >(result));
32555 return resultobj;
32556 fail:
32557 return NULL;
32558 }
32559
32560
32561 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32562 PyObject *resultobj = 0;
32563 wxWindow *arg1 = (wxWindow *) 0 ;
32564 int result;
32565 void *argp1 = 0 ;
32566 int res1 = 0 ;
32567 PyObject *swig_obj[1] ;
32568
32569 if (!args) SWIG_fail;
32570 swig_obj[0] = args;
32571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32574 }
32575 arg1 = reinterpret_cast< wxWindow * >(argp1);
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 resultobj = SWIG_From_int(static_cast< int >(result));
32583 return resultobj;
32584 fail:
32585 return NULL;
32586 }
32587
32588
32589 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32590 PyObject *resultobj = 0;
32591 wxWindow *arg1 = (wxWindow *) 0 ;
32592 int result;
32593 void *argp1 = 0 ;
32594 int res1 = 0 ;
32595 PyObject *swig_obj[1] ;
32596
32597 if (!args) SWIG_fail;
32598 swig_obj[0] = args;
32599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32602 }
32603 arg1 = reinterpret_cast< wxWindow * >(argp1);
32604 {
32605 PyThreadState* __tstate = wxPyBeginAllowThreads();
32606 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32607 wxPyEndAllowThreads(__tstate);
32608 if (PyErr_Occurred()) SWIG_fail;
32609 }
32610 resultobj = SWIG_From_int(static_cast< int >(result));
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj = 0;
32619 wxWindow *arg1 = (wxWindow *) 0 ;
32620 wxSize *arg2 = 0 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 wxSize temp2 ;
32624 PyObject * obj0 = 0 ;
32625 PyObject * obj1 = 0 ;
32626 char * kwnames[] = {
32627 (char *) "self",(char *) "size", NULL
32628 };
32629
32630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32632 if (!SWIG_IsOK(res1)) {
32633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32634 }
32635 arg1 = reinterpret_cast< wxWindow * >(argp1);
32636 {
32637 arg2 = &temp2;
32638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32639 }
32640 {
32641 PyThreadState* __tstate = wxPyBeginAllowThreads();
32642 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 resultobj = SWIG_Py_Void();
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32654 PyObject *resultobj = 0;
32655 wxWindow *arg1 = (wxWindow *) 0 ;
32656 int arg2 ;
32657 int arg3 ;
32658 void *argp1 = 0 ;
32659 int res1 = 0 ;
32660 int val2 ;
32661 int ecode2 = 0 ;
32662 int val3 ;
32663 int ecode3 = 0 ;
32664 PyObject * obj0 = 0 ;
32665 PyObject * obj1 = 0 ;
32666 PyObject * obj2 = 0 ;
32667 char * kwnames[] = {
32668 (char *) "self",(char *) "w",(char *) "h", NULL
32669 };
32670
32671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32673 if (!SWIG_IsOK(res1)) {
32674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32675 }
32676 arg1 = reinterpret_cast< wxWindow * >(argp1);
32677 ecode2 = SWIG_AsVal_int(obj1, &val2);
32678 if (!SWIG_IsOK(ecode2)) {
32679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32680 }
32681 arg2 = static_cast< int >(val2);
32682 ecode3 = SWIG_AsVal_int(obj2, &val3);
32683 if (!SWIG_IsOK(ecode3)) {
32684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32685 }
32686 arg3 = static_cast< int >(val3);
32687 {
32688 PyThreadState* __tstate = wxPyBeginAllowThreads();
32689 (arg1)->SetVirtualSize(arg2,arg3);
32690 wxPyEndAllowThreads(__tstate);
32691 if (PyErr_Occurred()) SWIG_fail;
32692 }
32693 resultobj = SWIG_Py_Void();
32694 return resultobj;
32695 fail:
32696 return NULL;
32697 }
32698
32699
32700 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32701 PyObject *resultobj = 0;
32702 wxWindow *arg1 = (wxWindow *) 0 ;
32703 wxSize result;
32704 void *argp1 = 0 ;
32705 int res1 = 0 ;
32706 PyObject *swig_obj[1] ;
32707
32708 if (!args) SWIG_fail;
32709 swig_obj[0] = args;
32710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32711 if (!SWIG_IsOK(res1)) {
32712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32713 }
32714 arg1 = reinterpret_cast< wxWindow * >(argp1);
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 result = ((wxWindow const *)arg1)->GetVirtualSize();
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32729 PyObject *resultobj = 0;
32730 wxWindow *arg1 = (wxWindow *) 0 ;
32731 int *arg2 = (int *) 0 ;
32732 int *arg3 = (int *) 0 ;
32733 void *argp1 = 0 ;
32734 int res1 = 0 ;
32735 int temp2 ;
32736 int res2 = SWIG_TMPOBJ ;
32737 int temp3 ;
32738 int res3 = SWIG_TMPOBJ ;
32739 PyObject *swig_obj[1] ;
32740
32741 arg2 = &temp2;
32742 arg3 = &temp3;
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32748 }
32749 arg1 = reinterpret_cast< wxWindow * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 resultobj = SWIG_Py_Void();
32757 if (SWIG_IsTmpObj(res2)) {
32758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32759 } else {
32760 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32762 }
32763 if (SWIG_IsTmpObj(res3)) {
32764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32765 } else {
32766 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32768 }
32769 return resultobj;
32770 fail:
32771 return NULL;
32772 }
32773
32774
32775 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32776 PyObject *resultobj = 0;
32777 wxWindow *arg1 = (wxWindow *) 0 ;
32778 wxSize result;
32779 void *argp1 = 0 ;
32780 int res1 = 0 ;
32781 PyObject *swig_obj[1] ;
32782
32783 if (!args) SWIG_fail;
32784 swig_obj[0] = args;
32785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32786 if (!SWIG_IsOK(res1)) {
32787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32788 }
32789 arg1 = reinterpret_cast< wxWindow * >(argp1);
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32804 PyObject *resultobj = 0;
32805 wxWindow *arg1 = (wxWindow *) 0 ;
32806 bool arg2 = (bool) true ;
32807 bool result;
32808 void *argp1 = 0 ;
32809 int res1 = 0 ;
32810 bool val2 ;
32811 int ecode2 = 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 char * kwnames[] = {
32815 (char *) "self",(char *) "show", NULL
32816 };
32817
32818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 if (obj1) {
32825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32826 if (!SWIG_IsOK(ecode2)) {
32827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32828 }
32829 arg2 = static_cast< bool >(val2);
32830 }
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 result = (bool)(arg1)->Show(arg2);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 {
32838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32839 }
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32847 PyObject *resultobj = 0;
32848 wxWindow *arg1 = (wxWindow *) 0 ;
32849 bool result;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 PyObject *swig_obj[1] ;
32853
32854 if (!args) SWIG_fail;
32855 swig_obj[0] = args;
32856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32857 if (!SWIG_IsOK(res1)) {
32858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32859 }
32860 arg1 = reinterpret_cast< wxWindow * >(argp1);
32861 {
32862 PyThreadState* __tstate = wxPyBeginAllowThreads();
32863 result = (bool)(arg1)->Hide();
32864 wxPyEndAllowThreads(__tstate);
32865 if (PyErr_Occurred()) SWIG_fail;
32866 }
32867 {
32868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32869 }
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32877 PyObject *resultobj = 0;
32878 wxWindow *arg1 = (wxWindow *) 0 ;
32879 bool arg2 = (bool) true ;
32880 bool result;
32881 void *argp1 = 0 ;
32882 int res1 = 0 ;
32883 bool val2 ;
32884 int ecode2 = 0 ;
32885 PyObject * obj0 = 0 ;
32886 PyObject * obj1 = 0 ;
32887 char * kwnames[] = {
32888 (char *) "self",(char *) "enable", NULL
32889 };
32890
32891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res1)) {
32894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32895 }
32896 arg1 = reinterpret_cast< wxWindow * >(argp1);
32897 if (obj1) {
32898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32899 if (!SWIG_IsOK(ecode2)) {
32900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32901 }
32902 arg2 = static_cast< bool >(val2);
32903 }
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 result = (bool)(arg1)->Enable(arg2);
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 {
32911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32912 }
32913 return resultobj;
32914 fail:
32915 return NULL;
32916 }
32917
32918
32919 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32920 PyObject *resultobj = 0;
32921 wxWindow *arg1 = (wxWindow *) 0 ;
32922 bool result;
32923 void *argp1 = 0 ;
32924 int res1 = 0 ;
32925 PyObject *swig_obj[1] ;
32926
32927 if (!args) SWIG_fail;
32928 swig_obj[0] = args;
32929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32930 if (!SWIG_IsOK(res1)) {
32931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32932 }
32933 arg1 = reinterpret_cast< wxWindow * >(argp1);
32934 {
32935 PyThreadState* __tstate = wxPyBeginAllowThreads();
32936 result = (bool)(arg1)->Disable();
32937 wxPyEndAllowThreads(__tstate);
32938 if (PyErr_Occurred()) SWIG_fail;
32939 }
32940 {
32941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32942 }
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32950 PyObject *resultobj = 0;
32951 wxWindow *arg1 = (wxWindow *) 0 ;
32952 bool result;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 PyObject *swig_obj[1] ;
32956
32957 if (!args) SWIG_fail;
32958 swig_obj[0] = args;
32959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32960 if (!SWIG_IsOK(res1)) {
32961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32962 }
32963 arg1 = reinterpret_cast< wxWindow * >(argp1);
32964 {
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 result = (bool)((wxWindow const *)arg1)->IsShown();
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 {
32971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32972 }
32973 return resultobj;
32974 fail:
32975 return NULL;
32976 }
32977
32978
32979 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32980 PyObject *resultobj = 0;
32981 wxWindow *arg1 = (wxWindow *) 0 ;
32982 bool result;
32983 void *argp1 = 0 ;
32984 int res1 = 0 ;
32985 PyObject *swig_obj[1] ;
32986
32987 if (!args) SWIG_fail;
32988 swig_obj[0] = args;
32989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 {
32995 PyThreadState* __tstate = wxPyBeginAllowThreads();
32996 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 {
33001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33002 }
33003 return resultobj;
33004 fail:
33005 return NULL;
33006 }
33007
33008
33009 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33010 PyObject *resultobj = 0;
33011 wxWindow *arg1 = (wxWindow *) 0 ;
33012 long arg2 ;
33013 void *argp1 = 0 ;
33014 int res1 = 0 ;
33015 long val2 ;
33016 int ecode2 = 0 ;
33017 PyObject * obj0 = 0 ;
33018 PyObject * obj1 = 0 ;
33019 char * kwnames[] = {
33020 (char *) "self",(char *) "style", NULL
33021 };
33022
33023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33025 if (!SWIG_IsOK(res1)) {
33026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33027 }
33028 arg1 = reinterpret_cast< wxWindow * >(argp1);
33029 ecode2 = SWIG_AsVal_long(obj1, &val2);
33030 if (!SWIG_IsOK(ecode2)) {
33031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33032 }
33033 arg2 = static_cast< long >(val2);
33034 {
33035 PyThreadState* __tstate = wxPyBeginAllowThreads();
33036 (arg1)->SetWindowStyleFlag(arg2);
33037 wxPyEndAllowThreads(__tstate);
33038 if (PyErr_Occurred()) SWIG_fail;
33039 }
33040 resultobj = SWIG_Py_Void();
33041 return resultobj;
33042 fail:
33043 return NULL;
33044 }
33045
33046
33047 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33048 PyObject *resultobj = 0;
33049 wxWindow *arg1 = (wxWindow *) 0 ;
33050 long result;
33051 void *argp1 = 0 ;
33052 int res1 = 0 ;
33053 PyObject *swig_obj[1] ;
33054
33055 if (!args) SWIG_fail;
33056 swig_obj[0] = args;
33057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33058 if (!SWIG_IsOK(res1)) {
33059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33060 }
33061 arg1 = reinterpret_cast< wxWindow * >(argp1);
33062 {
33063 PyThreadState* __tstate = wxPyBeginAllowThreads();
33064 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33065 wxPyEndAllowThreads(__tstate);
33066 if (PyErr_Occurred()) SWIG_fail;
33067 }
33068 resultobj = SWIG_From_long(static_cast< long >(result));
33069 return resultobj;
33070 fail:
33071 return NULL;
33072 }
33073
33074
33075 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33076 PyObject *resultobj = 0;
33077 wxWindow *arg1 = (wxWindow *) 0 ;
33078 int arg2 ;
33079 bool result;
33080 void *argp1 = 0 ;
33081 int res1 = 0 ;
33082 int val2 ;
33083 int ecode2 = 0 ;
33084 PyObject * obj0 = 0 ;
33085 PyObject * obj1 = 0 ;
33086 char * kwnames[] = {
33087 (char *) "self",(char *) "flag", NULL
33088 };
33089
33090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33092 if (!SWIG_IsOK(res1)) {
33093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33094 }
33095 arg1 = reinterpret_cast< wxWindow * >(argp1);
33096 ecode2 = SWIG_AsVal_int(obj1, &val2);
33097 if (!SWIG_IsOK(ecode2)) {
33098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33099 }
33100 arg2 = static_cast< int >(val2);
33101 {
33102 PyThreadState* __tstate = wxPyBeginAllowThreads();
33103 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33104 wxPyEndAllowThreads(__tstate);
33105 if (PyErr_Occurred()) SWIG_fail;
33106 }
33107 {
33108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33109 }
33110 return resultobj;
33111 fail:
33112 return NULL;
33113 }
33114
33115
33116 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33117 PyObject *resultobj = 0;
33118 wxWindow *arg1 = (wxWindow *) 0 ;
33119 bool result;
33120 void *argp1 = 0 ;
33121 int res1 = 0 ;
33122 PyObject *swig_obj[1] ;
33123
33124 if (!args) SWIG_fail;
33125 swig_obj[0] = args;
33126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33127 if (!SWIG_IsOK(res1)) {
33128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33129 }
33130 arg1 = reinterpret_cast< wxWindow * >(argp1);
33131 {
33132 PyThreadState* __tstate = wxPyBeginAllowThreads();
33133 result = (bool)((wxWindow const *)arg1)->IsRetained();
33134 wxPyEndAllowThreads(__tstate);
33135 if (PyErr_Occurred()) SWIG_fail;
33136 }
33137 {
33138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33139 }
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33147 PyObject *resultobj = 0;
33148 wxWindow *arg1 = (wxWindow *) 0 ;
33149 long arg2 ;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 long val2 ;
33153 int ecode2 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char * kwnames[] = {
33157 (char *) "self",(char *) "exStyle", NULL
33158 };
33159
33160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 ecode2 = SWIG_AsVal_long(obj1, &val2);
33167 if (!SWIG_IsOK(ecode2)) {
33168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33169 }
33170 arg2 = static_cast< long >(val2);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 (arg1)->SetExtraStyle(arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 resultobj = SWIG_Py_Void();
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33185 PyObject *resultobj = 0;
33186 wxWindow *arg1 = (wxWindow *) 0 ;
33187 long result;
33188 void *argp1 = 0 ;
33189 int res1 = 0 ;
33190 PyObject *swig_obj[1] ;
33191
33192 if (!args) SWIG_fail;
33193 swig_obj[0] = args;
33194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33197 }
33198 arg1 = reinterpret_cast< wxWindow * >(argp1);
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_From_long(static_cast< long >(result));
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 bool arg2 = (bool) true ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 bool val2 ;
33219 int ecode2 = 0 ;
33220 PyObject * obj0 = 0 ;
33221 PyObject * obj1 = 0 ;
33222 char * kwnames[] = {
33223 (char *) "self",(char *) "modal", NULL
33224 };
33225
33226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33230 }
33231 arg1 = reinterpret_cast< wxWindow * >(argp1);
33232 if (obj1) {
33233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33234 if (!SWIG_IsOK(ecode2)) {
33235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33236 }
33237 arg2 = static_cast< bool >(val2);
33238 }
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 (arg1)->MakeModal(arg2);
33242 wxPyEndAllowThreads(__tstate);
33243 if (PyErr_Occurred()) SWIG_fail;
33244 }
33245 resultobj = SWIG_Py_Void();
33246 return resultobj;
33247 fail:
33248 return NULL;
33249 }
33250
33251
33252 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33253 PyObject *resultobj = 0;
33254 wxWindow *arg1 = (wxWindow *) 0 ;
33255 bool arg2 ;
33256 void *argp1 = 0 ;
33257 int res1 = 0 ;
33258 bool val2 ;
33259 int ecode2 = 0 ;
33260 PyObject * obj0 = 0 ;
33261 PyObject * obj1 = 0 ;
33262 char * kwnames[] = {
33263 (char *) "self",(char *) "enableTheme", NULL
33264 };
33265
33266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res1)) {
33269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33270 }
33271 arg1 = reinterpret_cast< wxWindow * >(argp1);
33272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33273 if (!SWIG_IsOK(ecode2)) {
33274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33275 }
33276 arg2 = static_cast< bool >(val2);
33277 {
33278 PyThreadState* __tstate = wxPyBeginAllowThreads();
33279 (arg1)->SetThemeEnabled(arg2);
33280 wxPyEndAllowThreads(__tstate);
33281 if (PyErr_Occurred()) SWIG_fail;
33282 }
33283 resultobj = SWIG_Py_Void();
33284 return resultobj;
33285 fail:
33286 return NULL;
33287 }
33288
33289
33290 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33291 PyObject *resultobj = 0;
33292 wxWindow *arg1 = (wxWindow *) 0 ;
33293 bool result;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 PyObject *swig_obj[1] ;
33297
33298 if (!args) SWIG_fail;
33299 swig_obj[0] = args;
33300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33313 }
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 void *argp1 = 0 ;
33324 int res1 = 0 ;
33325 PyObject *swig_obj[1] ;
33326
33327 if (!args) SWIG_fail;
33328 swig_obj[0] = args;
33329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33330 if (!SWIG_IsOK(res1)) {
33331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33332 }
33333 arg1 = reinterpret_cast< wxWindow * >(argp1);
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 (arg1)->SetFocus();
33337 wxPyEndAllowThreads(__tstate);
33338 if (PyErr_Occurred()) SWIG_fail;
33339 }
33340 resultobj = SWIG_Py_Void();
33341 return resultobj;
33342 fail:
33343 return NULL;
33344 }
33345
33346
33347 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33348 PyObject *resultobj = 0;
33349 wxWindow *arg1 = (wxWindow *) 0 ;
33350 void *argp1 = 0 ;
33351 int res1 = 0 ;
33352 PyObject *swig_obj[1] ;
33353
33354 if (!args) SWIG_fail;
33355 swig_obj[0] = args;
33356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 {
33362 PyThreadState* __tstate = wxPyBeginAllowThreads();
33363 (arg1)->SetFocusFromKbd();
33364 wxPyEndAllowThreads(__tstate);
33365 if (PyErr_Occurred()) SWIG_fail;
33366 }
33367 resultobj = SWIG_Py_Void();
33368 return resultobj;
33369 fail:
33370 return NULL;
33371 }
33372
33373
33374 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33375 PyObject *resultobj = 0;
33376 wxWindow *result = 0 ;
33377
33378 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33379 {
33380 if (!wxPyCheckForApp()) SWIG_fail;
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (wxWindow *)wxWindow::FindFocus();
33383 wxPyEndAllowThreads(__tstate);
33384 if (PyErr_Occurred()) SWIG_fail;
33385 }
33386 {
33387 resultobj = wxPyMake_wxObject(result, 0);
33388 }
33389 return resultobj;
33390 fail:
33391 return NULL;
33392 }
33393
33394
33395 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33396 PyObject *resultobj = 0;
33397 wxWindow *arg1 = (wxWindow *) 0 ;
33398 bool result;
33399 void *argp1 = 0 ;
33400 int res1 = 0 ;
33401 PyObject *swig_obj[1] ;
33402
33403 if (!args) SWIG_fail;
33404 swig_obj[0] = args;
33405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33406 if (!SWIG_IsOK(res1)) {
33407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33408 }
33409 arg1 = reinterpret_cast< wxWindow * >(argp1);
33410 {
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33418 }
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 bool result;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 PyObject *swig_obj[1] ;
33432
33433 if (!args) SWIG_fail;
33434 swig_obj[0] = args;
33435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 {
33447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33448 }
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33459 bool result;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 int val2 ;
33463 int ecode2 = 0 ;
33464 PyObject * obj0 = 0 ;
33465 PyObject * obj1 = 0 ;
33466 char * kwnames[] = {
33467 (char *) "self",(char *) "flags", NULL
33468 };
33469
33470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33474 }
33475 arg1 = reinterpret_cast< wxWindow * >(argp1);
33476 if (obj1) {
33477 ecode2 = SWIG_AsVal_int(obj1, &val2);
33478 if (!SWIG_IsOK(ecode2)) {
33479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33480 }
33481 arg2 = static_cast< int >(val2);
33482 }
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 result = (bool)(arg1)->Navigate(arg2);
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 {
33490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33491 }
33492 return resultobj;
33493 fail:
33494 return NULL;
33495 }
33496
33497
33498 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33499 PyObject *resultobj = 0;
33500 wxWindow *arg1 = (wxWindow *) 0 ;
33501 wxWindow *arg2 = (wxWindow *) 0 ;
33502 void *argp1 = 0 ;
33503 int res1 = 0 ;
33504 void *argp2 = 0 ;
33505 int res2 = 0 ;
33506 PyObject * obj0 = 0 ;
33507 PyObject * obj1 = 0 ;
33508 char * kwnames[] = {
33509 (char *) "self",(char *) "win", NULL
33510 };
33511
33512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33514 if (!SWIG_IsOK(res1)) {
33515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33516 }
33517 arg1 = reinterpret_cast< wxWindow * >(argp1);
33518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res2)) {
33520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33521 }
33522 arg2 = reinterpret_cast< wxWindow * >(argp2);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 (arg1)->MoveAfterInTabOrder(arg2);
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 resultobj = SWIG_Py_Void();
33530 return resultobj;
33531 fail:
33532 return NULL;
33533 }
33534
33535
33536 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33537 PyObject *resultobj = 0;
33538 wxWindow *arg1 = (wxWindow *) 0 ;
33539 wxWindow *arg2 = (wxWindow *) 0 ;
33540 void *argp1 = 0 ;
33541 int res1 = 0 ;
33542 void *argp2 = 0 ;
33543 int res2 = 0 ;
33544 PyObject * obj0 = 0 ;
33545 PyObject * obj1 = 0 ;
33546 char * kwnames[] = {
33547 (char *) "self",(char *) "win", NULL
33548 };
33549
33550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33552 if (!SWIG_IsOK(res1)) {
33553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33554 }
33555 arg1 = reinterpret_cast< wxWindow * >(argp1);
33556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33557 if (!SWIG_IsOK(res2)) {
33558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33559 }
33560 arg2 = reinterpret_cast< wxWindow * >(argp2);
33561 {
33562 PyThreadState* __tstate = wxPyBeginAllowThreads();
33563 (arg1)->MoveBeforeInTabOrder(arg2);
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 resultobj = SWIG_Py_Void();
33568 return resultobj;
33569 fail:
33570 return NULL;
33571 }
33572
33573
33574 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33575 PyObject *resultobj = 0;
33576 wxWindow *arg1 = (wxWindow *) 0 ;
33577 PyObject *result = 0 ;
33578 void *argp1 = 0 ;
33579 int res1 = 0 ;
33580 PyObject *swig_obj[1] ;
33581
33582 if (!args) SWIG_fail;
33583 swig_obj[0] = args;
33584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33587 }
33588 arg1 = reinterpret_cast< wxWindow * >(argp1);
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (PyObject *)wxWindow_GetChildren(arg1);
33592 wxPyEndAllowThreads(__tstate);
33593 if (PyErr_Occurred()) SWIG_fail;
33594 }
33595 resultobj = result;
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33603 PyObject *resultobj = 0;
33604 wxWindow *arg1 = (wxWindow *) 0 ;
33605 wxWindow *result = 0 ;
33606 void *argp1 = 0 ;
33607 int res1 = 0 ;
33608 PyObject *swig_obj[1] ;
33609
33610 if (!args) SWIG_fail;
33611 swig_obj[0] = args;
33612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33613 if (!SWIG_IsOK(res1)) {
33614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33615 }
33616 arg1 = reinterpret_cast< wxWindow * >(argp1);
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 {
33624 resultobj = wxPyMake_wxObject(result, 0);
33625 }
33626 return resultobj;
33627 fail:
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 PyObject *resultobj = 0;
33634 wxWindow *arg1 = (wxWindow *) 0 ;
33635 wxWindow *result = 0 ;
33636 void *argp1 = 0 ;
33637 int res1 = 0 ;
33638 PyObject *swig_obj[1] ;
33639
33640 if (!args) SWIG_fail;
33641 swig_obj[0] = args;
33642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33643 if (!SWIG_IsOK(res1)) {
33644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33645 }
33646 arg1 = reinterpret_cast< wxWindow * >(argp1);
33647 {
33648 PyThreadState* __tstate = wxPyBeginAllowThreads();
33649 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 {
33654 resultobj = wxPyMake_wxObject(result, 0);
33655 }
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *resultobj = 0;
33664 wxWindow *arg1 = (wxWindow *) 0 ;
33665 bool result;
33666 void *argp1 = 0 ;
33667 int res1 = 0 ;
33668 PyObject *swig_obj[1] ;
33669
33670 if (!args) SWIG_fail;
33671 swig_obj[0] = args;
33672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33685 }
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj = 0;
33694 wxWindow *arg1 = (wxWindow *) 0 ;
33695 wxWindow *arg2 = (wxWindow *) 0 ;
33696 bool result;
33697 void *argp1 = 0 ;
33698 int res1 = 0 ;
33699 void *argp2 = 0 ;
33700 int res2 = 0 ;
33701 PyObject * obj0 = 0 ;
33702 PyObject * obj1 = 0 ;
33703 char * kwnames[] = {
33704 (char *) "self",(char *) "newParent", NULL
33705 };
33706
33707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33709 if (!SWIG_IsOK(res1)) {
33710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33711 }
33712 arg1 = reinterpret_cast< wxWindow * >(argp1);
33713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res2)) {
33715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33716 }
33717 arg2 = reinterpret_cast< wxWindow * >(argp2);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = (bool)(arg1)->Reparent(arg2);
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33726 }
33727 return resultobj;
33728 fail:
33729 return NULL;
33730 }
33731
33732
33733 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33734 PyObject *resultobj = 0;
33735 wxWindow *arg1 = (wxWindow *) 0 ;
33736 wxWindow *arg2 = (wxWindow *) 0 ;
33737 void *argp1 = 0 ;
33738 int res1 = 0 ;
33739 void *argp2 = 0 ;
33740 int res2 = 0 ;
33741 PyObject * obj0 = 0 ;
33742 PyObject * obj1 = 0 ;
33743 char * kwnames[] = {
33744 (char *) "self",(char *) "child", NULL
33745 };
33746
33747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33749 if (!SWIG_IsOK(res1)) {
33750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33751 }
33752 arg1 = reinterpret_cast< wxWindow * >(argp1);
33753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33754 if (!SWIG_IsOK(res2)) {
33755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33756 }
33757 arg2 = reinterpret_cast< wxWindow * >(argp2);
33758 {
33759 PyThreadState* __tstate = wxPyBeginAllowThreads();
33760 (arg1)->AddChild(arg2);
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 resultobj = SWIG_Py_Void();
33765 return resultobj;
33766 fail:
33767 return NULL;
33768 }
33769
33770
33771 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33772 PyObject *resultobj = 0;
33773 wxWindow *arg1 = (wxWindow *) 0 ;
33774 wxWindow *arg2 = (wxWindow *) 0 ;
33775 void *argp1 = 0 ;
33776 int res1 = 0 ;
33777 void *argp2 = 0 ;
33778 int res2 = 0 ;
33779 PyObject * obj0 = 0 ;
33780 PyObject * obj1 = 0 ;
33781 char * kwnames[] = {
33782 (char *) "self",(char *) "child", NULL
33783 };
33784
33785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33787 if (!SWIG_IsOK(res1)) {
33788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33789 }
33790 arg1 = reinterpret_cast< wxWindow * >(argp1);
33791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33792 if (!SWIG_IsOK(res2)) {
33793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33794 }
33795 arg2 = reinterpret_cast< wxWindow * >(argp2);
33796 {
33797 PyThreadState* __tstate = wxPyBeginAllowThreads();
33798 (arg1)->RemoveChild(arg2);
33799 wxPyEndAllowThreads(__tstate);
33800 if (PyErr_Occurred()) SWIG_fail;
33801 }
33802 resultobj = SWIG_Py_Void();
33803 return resultobj;
33804 fail:
33805 return NULL;
33806 }
33807
33808
33809 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33810 PyObject *resultobj = 0;
33811 wxWindow *arg1 = (wxWindow *) 0 ;
33812 bool arg2 ;
33813 void *argp1 = 0 ;
33814 int res1 = 0 ;
33815 bool val2 ;
33816 int ecode2 = 0 ;
33817 PyObject * obj0 = 0 ;
33818 PyObject * obj1 = 0 ;
33819 char * kwnames[] = {
33820 (char *) "self",(char *) "on", NULL
33821 };
33822
33823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33825 if (!SWIG_IsOK(res1)) {
33826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33827 }
33828 arg1 = reinterpret_cast< wxWindow * >(argp1);
33829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33830 if (!SWIG_IsOK(ecode2)) {
33831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33832 }
33833 arg2 = static_cast< bool >(val2);
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 wxWindow_SetDoubleBuffered(arg1,arg2);
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 resultobj = SWIG_Py_Void();
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = 0;
33849 wxWindow *arg1 = (wxWindow *) 0 ;
33850 long arg2 ;
33851 wxWindow *result = 0 ;
33852 void *argp1 = 0 ;
33853 int res1 = 0 ;
33854 long val2 ;
33855 int ecode2 = 0 ;
33856 PyObject * obj0 = 0 ;
33857 PyObject * obj1 = 0 ;
33858 char * kwnames[] = {
33859 (char *) "self",(char *) "winid", NULL
33860 };
33861
33862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33864 if (!SWIG_IsOK(res1)) {
33865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33866 }
33867 arg1 = reinterpret_cast< wxWindow * >(argp1);
33868 ecode2 = SWIG_AsVal_long(obj1, &val2);
33869 if (!SWIG_IsOK(ecode2)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33871 }
33872 arg2 = static_cast< long >(val2);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (wxWindow *)(arg1)->FindWindow(arg2);
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 {
33880 resultobj = wxPyMake_wxObject(result, 0);
33881 }
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33889 PyObject *resultobj = 0;
33890 wxWindow *arg1 = (wxWindow *) 0 ;
33891 wxString *arg2 = 0 ;
33892 wxWindow *result = 0 ;
33893 void *argp1 = 0 ;
33894 int res1 = 0 ;
33895 bool temp2 = false ;
33896 PyObject * obj0 = 0 ;
33897 PyObject * obj1 = 0 ;
33898 char * kwnames[] = {
33899 (char *) "self",(char *) "name", NULL
33900 };
33901
33902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33904 if (!SWIG_IsOK(res1)) {
33905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33906 }
33907 arg1 = reinterpret_cast< wxWindow * >(argp1);
33908 {
33909 arg2 = wxString_in_helper(obj1);
33910 if (arg2 == NULL) SWIG_fail;
33911 temp2 = true;
33912 }
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 {
33920 resultobj = wxPyMake_wxObject(result, 0);
33921 }
33922 {
33923 if (temp2)
33924 delete arg2;
33925 }
33926 return resultobj;
33927 fail:
33928 {
33929 if (temp2)
33930 delete arg2;
33931 }
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 wxEvtHandler *result = 0 ;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 PyObject *swig_obj[1] ;
33943
33944 if (!args) SWIG_fail;
33945 swig_obj[0] = args;
33946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33949 }
33950 arg1 = reinterpret_cast< wxWindow * >(argp1);
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 {
33958 resultobj = wxPyMake_wxObject(result, 0);
33959 }
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 wxWindow *arg1 = (wxWindow *) 0 ;
33969 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33970 void *argp1 = 0 ;
33971 int res1 = 0 ;
33972 void *argp2 = 0 ;
33973 int res2 = 0 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "handler", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33987 if (!SWIG_IsOK(res2)) {
33988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33989 }
33990 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 (arg1)->SetEventHandler(arg2);
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 resultobj = SWIG_Py_Void();
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj = 0;
34006 wxWindow *arg1 = (wxWindow *) 0 ;
34007 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 void *argp2 = 0 ;
34011 int res2 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char * kwnames[] = {
34015 (char *) "self",(char *) "handler", NULL
34016 };
34017
34018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34020 if (!SWIG_IsOK(res1)) {
34021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34022 }
34023 arg1 = reinterpret_cast< wxWindow * >(argp1);
34024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34025 if (!SWIG_IsOK(res2)) {
34026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34027 }
34028 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 (arg1)->PushEventHandler(arg2);
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_Py_Void();
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34043 PyObject *resultobj = 0;
34044 wxWindow *arg1 = (wxWindow *) 0 ;
34045 bool arg2 = (bool) false ;
34046 wxEvtHandler *result = 0 ;
34047 void *argp1 = 0 ;
34048 int res1 = 0 ;
34049 bool val2 ;
34050 int ecode2 = 0 ;
34051 PyObject * obj0 = 0 ;
34052 PyObject * obj1 = 0 ;
34053 char * kwnames[] = {
34054 (char *) "self",(char *) "deleteHandler", NULL
34055 };
34056
34057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34059 if (!SWIG_IsOK(res1)) {
34060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34061 }
34062 arg1 = reinterpret_cast< wxWindow * >(argp1);
34063 if (obj1) {
34064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34065 if (!SWIG_IsOK(ecode2)) {
34066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34067 }
34068 arg2 = static_cast< bool >(val2);
34069 }
34070 {
34071 PyThreadState* __tstate = wxPyBeginAllowThreads();
34072 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34073 wxPyEndAllowThreads(__tstate);
34074 if (PyErr_Occurred()) SWIG_fail;
34075 }
34076 {
34077 resultobj = wxPyMake_wxObject(result, 0);
34078 }
34079 return resultobj;
34080 fail:
34081 return NULL;
34082 }
34083
34084
34085 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34086 PyObject *resultobj = 0;
34087 wxWindow *arg1 = (wxWindow *) 0 ;
34088 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34089 bool result;
34090 void *argp1 = 0 ;
34091 int res1 = 0 ;
34092 void *argp2 = 0 ;
34093 int res2 = 0 ;
34094 PyObject * obj0 = 0 ;
34095 PyObject * obj1 = 0 ;
34096 char * kwnames[] = {
34097 (char *) "self",(char *) "handler", NULL
34098 };
34099
34100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34102 if (!SWIG_IsOK(res1)) {
34103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34104 }
34105 arg1 = reinterpret_cast< wxWindow * >(argp1);
34106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34107 if (!SWIG_IsOK(res2)) {
34108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34109 }
34110 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (bool)(arg1)->RemoveEventHandler(arg2);
34114 wxPyEndAllowThreads(__tstate);
34115 if (PyErr_Occurred()) SWIG_fail;
34116 }
34117 {
34118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34119 }
34120 return resultobj;
34121 fail:
34122 return NULL;
34123 }
34124
34125
34126 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34127 PyObject *resultobj = 0;
34128 wxWindow *arg1 = (wxWindow *) 0 ;
34129 wxValidator *arg2 = 0 ;
34130 void *argp1 = 0 ;
34131 int res1 = 0 ;
34132 void *argp2 = 0 ;
34133 int res2 = 0 ;
34134 PyObject * obj0 = 0 ;
34135 PyObject * obj1 = 0 ;
34136 char * kwnames[] = {
34137 (char *) "self",(char *) "validator", NULL
34138 };
34139
34140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34142 if (!SWIG_IsOK(res1)) {
34143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34144 }
34145 arg1 = reinterpret_cast< wxWindow * >(argp1);
34146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34147 if (!SWIG_IsOK(res2)) {
34148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34149 }
34150 if (!argp2) {
34151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34152 }
34153 arg2 = reinterpret_cast< wxValidator * >(argp2);
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 (arg1)->SetValidator((wxValidator const &)*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_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34168 PyObject *resultobj = 0;
34169 wxWindow *arg1 = (wxWindow *) 0 ;
34170 wxValidator *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_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (wxValidator *)(arg1)->GetValidator();
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 {
34189 resultobj = wxPyMake_wxObject(result, (bool)0);
34190 }
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxWindow *arg1 = (wxWindow *) 0 ;
34200 bool result;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 result = (bool)(arg1)->Validate();
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 {
34219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34220 }
34221 return resultobj;
34222 fail:
34223 return NULL;
34224 }
34225
34226
34227 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxWindow *arg1 = (wxWindow *) 0 ;
34230 bool result;
34231 void *argp1 = 0 ;
34232 int res1 = 0 ;
34233 PyObject *swig_obj[1] ;
34234
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34240 }
34241 arg1 = reinterpret_cast< wxWindow * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (bool)(arg1)->TransferDataToWindow();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 {
34249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34250 }
34251 return resultobj;
34252 fail:
34253 return NULL;
34254 }
34255
34256
34257 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34258 PyObject *resultobj = 0;
34259 wxWindow *arg1 = (wxWindow *) 0 ;
34260 bool result;
34261 void *argp1 = 0 ;
34262 int res1 = 0 ;
34263 PyObject *swig_obj[1] ;
34264
34265 if (!args) SWIG_fail;
34266 swig_obj[0] = args;
34267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34268 if (!SWIG_IsOK(res1)) {
34269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34270 }
34271 arg1 = reinterpret_cast< wxWindow * >(argp1);
34272 {
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (bool)(arg1)->TransferDataFromWindow();
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 {
34279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34280 }
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 PyObject *swig_obj[1] ;
34293
34294 if (!args) SWIG_fail;
34295 swig_obj[0] = args;
34296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34297 if (!SWIG_IsOK(res1)) {
34298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34299 }
34300 arg1 = reinterpret_cast< wxWindow * >(argp1);
34301 {
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 (arg1)->InitDialog();
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 resultobj = SWIG_Py_Void();
34308 return resultobj;
34309 fail:
34310 return NULL;
34311 }
34312
34313
34314 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34315 PyObject *resultobj = 0;
34316 wxWindow *arg1 = (wxWindow *) 0 ;
34317 wxAcceleratorTable *arg2 = 0 ;
34318 void *argp1 = 0 ;
34319 int res1 = 0 ;
34320 void *argp2 = 0 ;
34321 int res2 = 0 ;
34322 PyObject * obj0 = 0 ;
34323 PyObject * obj1 = 0 ;
34324 char * kwnames[] = {
34325 (char *) "self",(char *) "accel", NULL
34326 };
34327
34328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34330 if (!SWIG_IsOK(res1)) {
34331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34332 }
34333 arg1 = reinterpret_cast< wxWindow * >(argp1);
34334 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34335 if (!SWIG_IsOK(res2)) {
34336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34337 }
34338 if (!argp2) {
34339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34340 }
34341 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_Py_Void();
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34356 PyObject *resultobj = 0;
34357 wxWindow *arg1 = (wxWindow *) 0 ;
34358 wxAcceleratorTable *result = 0 ;
34359 void *argp1 = 0 ;
34360 int res1 = 0 ;
34361 PyObject *swig_obj[1] ;
34362
34363 if (!args) SWIG_fail;
34364 swig_obj[0] = args;
34365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34366 if (!SWIG_IsOK(res1)) {
34367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34368 }
34369 arg1 = reinterpret_cast< wxWindow * >(argp1);
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34384 PyObject *resultobj = 0;
34385 wxWindow *arg1 = (wxWindow *) 0 ;
34386 int arg2 ;
34387 int arg3 ;
34388 int arg4 ;
34389 bool result;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 int val2 ;
34393 int ecode2 = 0 ;
34394 int val3 ;
34395 int ecode3 = 0 ;
34396 int val4 ;
34397 int ecode4 = 0 ;
34398 PyObject * obj0 = 0 ;
34399 PyObject * obj1 = 0 ;
34400 PyObject * obj2 = 0 ;
34401 PyObject * obj3 = 0 ;
34402 char * kwnames[] = {
34403 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34404 };
34405
34406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34408 if (!SWIG_IsOK(res1)) {
34409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34410 }
34411 arg1 = reinterpret_cast< wxWindow * >(argp1);
34412 ecode2 = SWIG_AsVal_int(obj1, &val2);
34413 if (!SWIG_IsOK(ecode2)) {
34414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34415 }
34416 arg2 = static_cast< int >(val2);
34417 ecode3 = SWIG_AsVal_int(obj2, &val3);
34418 if (!SWIG_IsOK(ecode3)) {
34419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34420 }
34421 arg3 = static_cast< int >(val3);
34422 ecode4 = SWIG_AsVal_int(obj3, &val4);
34423 if (!SWIG_IsOK(ecode4)) {
34424 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34425 }
34426 arg4 = static_cast< int >(val4);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 {
34434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34435 }
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 int arg2 ;
34446 bool result;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 int val2 ;
34450 int ecode2 = 0 ;
34451 PyObject * obj0 = 0 ;
34452 PyObject * obj1 = 0 ;
34453 char * kwnames[] = {
34454 (char *) "self",(char *) "hotkeyId", NULL
34455 };
34456
34457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34459 if (!SWIG_IsOK(res1)) {
34460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34461 }
34462 arg1 = reinterpret_cast< wxWindow * >(argp1);
34463 ecode2 = SWIG_AsVal_int(obj1, &val2);
34464 if (!SWIG_IsOK(ecode2)) {
34465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34466 }
34467 arg2 = static_cast< int >(val2);
34468 {
34469 PyThreadState* __tstate = wxPyBeginAllowThreads();
34470 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 {
34475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34476 }
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 wxPoint *arg2 = 0 ;
34487 wxPoint result;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 wxPoint temp2 ;
34491 PyObject * obj0 = 0 ;
34492 PyObject * obj1 = 0 ;
34493 char * kwnames[] = {
34494 (char *) "self",(char *) "pt", NULL
34495 };
34496
34497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34501 }
34502 arg1 = reinterpret_cast< wxWindow * >(argp1);
34503 {
34504 arg2 = &temp2;
34505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34506 }
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34514 return resultobj;
34515 fail:
34516 return NULL;
34517 }
34518
34519
34520 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34521 PyObject *resultobj = 0;
34522 wxWindow *arg1 = (wxWindow *) 0 ;
34523 wxSize *arg2 = 0 ;
34524 wxSize result;
34525 void *argp1 = 0 ;
34526 int res1 = 0 ;
34527 wxSize temp2 ;
34528 PyObject * obj0 = 0 ;
34529 PyObject * obj1 = 0 ;
34530 char * kwnames[] = {
34531 (char *) "self",(char *) "sz", NULL
34532 };
34533
34534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34538 }
34539 arg1 = reinterpret_cast< wxWindow * >(argp1);
34540 {
34541 arg2 = &temp2;
34542 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34543 }
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34558 PyObject *resultobj = 0;
34559 wxWindow *arg1 = (wxWindow *) 0 ;
34560 wxPoint *arg2 = 0 ;
34561 wxPoint result;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 wxPoint temp2 ;
34565 PyObject * obj0 = 0 ;
34566 PyObject * obj1 = 0 ;
34567 char * kwnames[] = {
34568 (char *) "self",(char *) "pt", NULL
34569 };
34570
34571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34573 if (!SWIG_IsOK(res1)) {
34574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34575 }
34576 arg1 = reinterpret_cast< wxWindow * >(argp1);
34577 {
34578 arg2 = &temp2;
34579 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34580 }
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 wxSize *arg2 = 0 ;
34598 wxSize result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 wxSize temp2 ;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34604 char * kwnames[] = {
34605 (char *) "self",(char *) "sz", NULL
34606 };
34607
34608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34610 if (!SWIG_IsOK(res1)) {
34611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34612 }
34613 arg1 = reinterpret_cast< wxWindow * >(argp1);
34614 {
34615 arg2 = &temp2;
34616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34617 }
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34621 wxPyEndAllowThreads(__tstate);
34622 if (PyErr_Occurred()) SWIG_fail;
34623 }
34624 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34625 return resultobj;
34626 fail:
34627 return NULL;
34628 }
34629
34630
34631 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34632 PyObject *resultobj = 0;
34633 wxWindow *arg1 = (wxWindow *) 0 ;
34634 wxPoint *arg2 = 0 ;
34635 wxPoint result;
34636 void *argp1 = 0 ;
34637 int res1 = 0 ;
34638 wxPoint temp2 ;
34639 PyObject * obj0 = 0 ;
34640 PyObject * obj1 = 0 ;
34641 char * kwnames[] = {
34642 (char *) "self",(char *) "pt", NULL
34643 };
34644
34645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34647 if (!SWIG_IsOK(res1)) {
34648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34649 }
34650 arg1 = reinterpret_cast< wxWindow * >(argp1);
34651 {
34652 arg2 = &temp2;
34653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34654 }
34655 {
34656 PyThreadState* __tstate = wxPyBeginAllowThreads();
34657 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34658 wxPyEndAllowThreads(__tstate);
34659 if (PyErr_Occurred()) SWIG_fail;
34660 }
34661 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34662 return resultobj;
34663 fail:
34664 return NULL;
34665 }
34666
34667
34668 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34669 PyObject *resultobj = 0;
34670 wxWindow *arg1 = (wxWindow *) 0 ;
34671 wxSize *arg2 = 0 ;
34672 wxSize result;
34673 void *argp1 = 0 ;
34674 int res1 = 0 ;
34675 wxSize temp2 ;
34676 PyObject * obj0 = 0 ;
34677 PyObject * obj1 = 0 ;
34678 char * kwnames[] = {
34679 (char *) "self",(char *) "sz", NULL
34680 };
34681
34682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34684 if (!SWIG_IsOK(res1)) {
34685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34686 }
34687 arg1 = reinterpret_cast< wxWindow * >(argp1);
34688 {
34689 arg2 = &temp2;
34690 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34691 }
34692 {
34693 PyThreadState* __tstate = wxPyBeginAllowThreads();
34694 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34695 wxPyEndAllowThreads(__tstate);
34696 if (PyErr_Occurred()) SWIG_fail;
34697 }
34698 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34706 PyObject *resultobj = 0;
34707 wxWindow *arg1 = (wxWindow *) 0 ;
34708 int arg2 ;
34709 int arg3 ;
34710 void *argp1 = 0 ;
34711 int res1 = 0 ;
34712 int val2 ;
34713 int ecode2 = 0 ;
34714 int val3 ;
34715 int ecode3 = 0 ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 PyObject * obj2 = 0 ;
34719 char * kwnames[] = {
34720 (char *) "self",(char *) "x",(char *) "y", NULL
34721 };
34722
34723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34725 if (!SWIG_IsOK(res1)) {
34726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34727 }
34728 arg1 = reinterpret_cast< wxWindow * >(argp1);
34729 ecode2 = SWIG_AsVal_int(obj1, &val2);
34730 if (!SWIG_IsOK(ecode2)) {
34731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34732 }
34733 arg2 = static_cast< int >(val2);
34734 ecode3 = SWIG_AsVal_int(obj2, &val3);
34735 if (!SWIG_IsOK(ecode3)) {
34736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34737 }
34738 arg3 = static_cast< int >(val3);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 (arg1)->WarpPointer(arg2,arg3);
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_Py_Void();
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34753 PyObject *resultobj = 0;
34754 wxWindow *arg1 = (wxWindow *) 0 ;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 PyObject *swig_obj[1] ;
34758
34759 if (!args) SWIG_fail;
34760 swig_obj[0] = args;
34761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34762 if (!SWIG_IsOK(res1)) {
34763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34764 }
34765 arg1 = reinterpret_cast< wxWindow * >(argp1);
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 (arg1)->CaptureMouse();
34769 wxPyEndAllowThreads(__tstate);
34770 if (PyErr_Occurred()) SWIG_fail;
34771 }
34772 resultobj = SWIG_Py_Void();
34773 return resultobj;
34774 fail:
34775 return NULL;
34776 }
34777
34778
34779 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34780 PyObject *resultobj = 0;
34781 wxWindow *arg1 = (wxWindow *) 0 ;
34782 void *argp1 = 0 ;
34783 int res1 = 0 ;
34784 PyObject *swig_obj[1] ;
34785
34786 if (!args) SWIG_fail;
34787 swig_obj[0] = args;
34788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34789 if (!SWIG_IsOK(res1)) {
34790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34791 }
34792 arg1 = reinterpret_cast< wxWindow * >(argp1);
34793 {
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 (arg1)->ReleaseMouse();
34796 wxPyEndAllowThreads(__tstate);
34797 if (PyErr_Occurred()) SWIG_fail;
34798 }
34799 resultobj = SWIG_Py_Void();
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34807 PyObject *resultobj = 0;
34808 wxWindow *result = 0 ;
34809
34810 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34811 {
34812 if (!wxPyCheckForApp()) SWIG_fail;
34813 PyThreadState* __tstate = wxPyBeginAllowThreads();
34814 result = (wxWindow *)wxWindow::GetCapture();
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 {
34819 resultobj = wxPyMake_wxObject(result, 0);
34820 }
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34828 PyObject *resultobj = 0;
34829 wxWindow *arg1 = (wxWindow *) 0 ;
34830 bool result;
34831 void *argp1 = 0 ;
34832 int res1 = 0 ;
34833 PyObject *swig_obj[1] ;
34834
34835 if (!args) SWIG_fail;
34836 swig_obj[0] = args;
34837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34838 if (!SWIG_IsOK(res1)) {
34839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34840 }
34841 arg1 = reinterpret_cast< wxWindow * >(argp1);
34842 {
34843 PyThreadState* __tstate = wxPyBeginAllowThreads();
34844 result = (bool)((wxWindow const *)arg1)->HasCapture();
34845 wxPyEndAllowThreads(__tstate);
34846 if (PyErr_Occurred()) SWIG_fail;
34847 }
34848 {
34849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34850 }
34851 return resultobj;
34852 fail:
34853 return NULL;
34854 }
34855
34856
34857 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34858 PyObject *resultobj = 0;
34859 wxWindow *arg1 = (wxWindow *) 0 ;
34860 bool arg2 = (bool) true ;
34861 wxRect *arg3 = (wxRect *) NULL ;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 bool val2 ;
34865 int ecode2 = 0 ;
34866 void *argp3 = 0 ;
34867 int res3 = 0 ;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 PyObject * obj2 = 0 ;
34871 char * kwnames[] = {
34872 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34873 };
34874
34875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 if (obj1) {
34882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34883 if (!SWIG_IsOK(ecode2)) {
34884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34885 }
34886 arg2 = static_cast< bool >(val2);
34887 }
34888 if (obj2) {
34889 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34890 if (!SWIG_IsOK(res3)) {
34891 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34892 }
34893 arg3 = reinterpret_cast< wxRect * >(argp3);
34894 }
34895 {
34896 PyThreadState* __tstate = wxPyBeginAllowThreads();
34897 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34898 wxPyEndAllowThreads(__tstate);
34899 if (PyErr_Occurred()) SWIG_fail;
34900 }
34901 resultobj = SWIG_Py_Void();
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj = 0;
34910 wxWindow *arg1 = (wxWindow *) 0 ;
34911 wxRect *arg2 = 0 ;
34912 bool arg3 = (bool) true ;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 wxRect temp2 ;
34916 bool val3 ;
34917 int ecode3 = 0 ;
34918 PyObject * obj0 = 0 ;
34919 PyObject * obj1 = 0 ;
34920 PyObject * obj2 = 0 ;
34921 char * kwnames[] = {
34922 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34923 };
34924
34925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34927 if (!SWIG_IsOK(res1)) {
34928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34929 }
34930 arg1 = reinterpret_cast< wxWindow * >(argp1);
34931 {
34932 arg2 = &temp2;
34933 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34934 }
34935 if (obj2) {
34936 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34937 if (!SWIG_IsOK(ecode3)) {
34938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34939 }
34940 arg3 = static_cast< bool >(val3);
34941 }
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34945 wxPyEndAllowThreads(__tstate);
34946 if (PyErr_Occurred()) SWIG_fail;
34947 }
34948 resultobj = SWIG_Py_Void();
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 PyObject *resultobj = 0;
34957 wxWindow *arg1 = (wxWindow *) 0 ;
34958 void *argp1 = 0 ;
34959 int res1 = 0 ;
34960 PyObject *swig_obj[1] ;
34961
34962 if (!args) SWIG_fail;
34963 swig_obj[0] = args;
34964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34965 if (!SWIG_IsOK(res1)) {
34966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34967 }
34968 arg1 = reinterpret_cast< wxWindow * >(argp1);
34969 {
34970 PyThreadState* __tstate = wxPyBeginAllowThreads();
34971 (arg1)->Update();
34972 wxPyEndAllowThreads(__tstate);
34973 if (PyErr_Occurred()) SWIG_fail;
34974 }
34975 resultobj = SWIG_Py_Void();
34976 return resultobj;
34977 fail:
34978 return NULL;
34979 }
34980
34981
34982 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34983 PyObject *resultobj = 0;
34984 wxWindow *arg1 = (wxWindow *) 0 ;
34985 void *argp1 = 0 ;
34986 int res1 = 0 ;
34987 PyObject *swig_obj[1] ;
34988
34989 if (!args) SWIG_fail;
34990 swig_obj[0] = args;
34991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34992 if (!SWIG_IsOK(res1)) {
34993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34994 }
34995 arg1 = reinterpret_cast< wxWindow * >(argp1);
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 (arg1)->ClearBackground();
34999 wxPyEndAllowThreads(__tstate);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 }
35002 resultobj = SWIG_Py_Void();
35003 return resultobj;
35004 fail:
35005 return NULL;
35006 }
35007
35008
35009 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35010 PyObject *resultobj = 0;
35011 wxWindow *arg1 = (wxWindow *) 0 ;
35012 void *argp1 = 0 ;
35013 int res1 = 0 ;
35014 PyObject *swig_obj[1] ;
35015
35016 if (!args) SWIG_fail;
35017 swig_obj[0] = args;
35018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35019 if (!SWIG_IsOK(res1)) {
35020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35021 }
35022 arg1 = reinterpret_cast< wxWindow * >(argp1);
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 (arg1)->Freeze();
35026 wxPyEndAllowThreads(__tstate);
35027 if (PyErr_Occurred()) SWIG_fail;
35028 }
35029 resultobj = SWIG_Py_Void();
35030 return resultobj;
35031 fail:
35032 return NULL;
35033 }
35034
35035
35036 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35037 PyObject *resultobj = 0;
35038 wxWindow *arg1 = (wxWindow *) 0 ;
35039 void *argp1 = 0 ;
35040 int res1 = 0 ;
35041 PyObject *swig_obj[1] ;
35042
35043 if (!args) SWIG_fail;
35044 swig_obj[0] = args;
35045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35046 if (!SWIG_IsOK(res1)) {
35047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35048 }
35049 arg1 = reinterpret_cast< wxWindow * >(argp1);
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 (arg1)->Thaw();
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_Py_Void();
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35064 PyObject *resultobj = 0;
35065 wxWindow *arg1 = (wxWindow *) 0 ;
35066 wxDC *arg2 = 0 ;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 void *argp2 = 0 ;
35070 int res2 = 0 ;
35071 PyObject * obj0 = 0 ;
35072 PyObject * obj1 = 0 ;
35073 char * kwnames[] = {
35074 (char *) "self",(char *) "dc", NULL
35075 };
35076
35077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35079 if (!SWIG_IsOK(res1)) {
35080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35081 }
35082 arg1 = reinterpret_cast< wxWindow * >(argp1);
35083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35084 if (!SWIG_IsOK(res2)) {
35085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35086 }
35087 if (!argp2) {
35088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35089 }
35090 arg2 = reinterpret_cast< wxDC * >(argp2);
35091 {
35092 PyThreadState* __tstate = wxPyBeginAllowThreads();
35093 (arg1)->PrepareDC(*arg2);
35094 wxPyEndAllowThreads(__tstate);
35095 if (PyErr_Occurred()) SWIG_fail;
35096 }
35097 resultobj = SWIG_Py_Void();
35098 return resultobj;
35099 fail:
35100 return NULL;
35101 }
35102
35103
35104 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35105 PyObject *resultobj = 0;
35106 wxWindow *arg1 = (wxWindow *) 0 ;
35107 wxRegion *result = 0 ;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 PyObject *swig_obj[1] ;
35111
35112 if (!args) SWIG_fail;
35113 swig_obj[0] = args;
35114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35115 if (!SWIG_IsOK(res1)) {
35116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35117 }
35118 arg1 = reinterpret_cast< wxWindow * >(argp1);
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 {
35122 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35123 result = (wxRegion *) &_result_ref;
35124 }
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxWindow *arg1 = (wxWindow *) 0 ;
35138 wxRect result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 int arg2 ;
35167 int arg3 ;
35168 int arg4 = (int) 1 ;
35169 int arg5 = (int) 1 ;
35170 bool result;
35171 void *argp1 = 0 ;
35172 int res1 = 0 ;
35173 int val2 ;
35174 int ecode2 = 0 ;
35175 int val3 ;
35176 int ecode3 = 0 ;
35177 int val4 ;
35178 int ecode4 = 0 ;
35179 int val5 ;
35180 int ecode5 = 0 ;
35181 PyObject * obj0 = 0 ;
35182 PyObject * obj1 = 0 ;
35183 PyObject * obj2 = 0 ;
35184 PyObject * obj3 = 0 ;
35185 PyObject * obj4 = 0 ;
35186 char * kwnames[] = {
35187 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35188 };
35189
35190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35192 if (!SWIG_IsOK(res1)) {
35193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35194 }
35195 arg1 = reinterpret_cast< wxWindow * >(argp1);
35196 ecode2 = SWIG_AsVal_int(obj1, &val2);
35197 if (!SWIG_IsOK(ecode2)) {
35198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35199 }
35200 arg2 = static_cast< int >(val2);
35201 ecode3 = SWIG_AsVal_int(obj2, &val3);
35202 if (!SWIG_IsOK(ecode3)) {
35203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35204 }
35205 arg3 = static_cast< int >(val3);
35206 if (obj3) {
35207 ecode4 = SWIG_AsVal_int(obj3, &val4);
35208 if (!SWIG_IsOK(ecode4)) {
35209 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35210 }
35211 arg4 = static_cast< int >(val4);
35212 }
35213 if (obj4) {
35214 ecode5 = SWIG_AsVal_int(obj4, &val5);
35215 if (!SWIG_IsOK(ecode5)) {
35216 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35217 }
35218 arg5 = static_cast< int >(val5);
35219 }
35220 {
35221 PyThreadState* __tstate = wxPyBeginAllowThreads();
35222 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35223 wxPyEndAllowThreads(__tstate);
35224 if (PyErr_Occurred()) SWIG_fail;
35225 }
35226 {
35227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35228 }
35229 return resultobj;
35230 fail:
35231 return NULL;
35232 }
35233
35234
35235 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35236 PyObject *resultobj = 0;
35237 wxWindow *arg1 = (wxWindow *) 0 ;
35238 wxPoint *arg2 = 0 ;
35239 bool result;
35240 void *argp1 = 0 ;
35241 int res1 = 0 ;
35242 wxPoint temp2 ;
35243 PyObject * obj0 = 0 ;
35244 PyObject * obj1 = 0 ;
35245 char * kwnames[] = {
35246 (char *) "self",(char *) "pt", NULL
35247 };
35248
35249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35251 if (!SWIG_IsOK(res1)) {
35252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35253 }
35254 arg1 = reinterpret_cast< wxWindow * >(argp1);
35255 {
35256 arg2 = &temp2;
35257 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35258 }
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35262 wxPyEndAllowThreads(__tstate);
35263 if (PyErr_Occurred()) SWIG_fail;
35264 }
35265 {
35266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35267 }
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35275 PyObject *resultobj = 0;
35276 wxWindow *arg1 = (wxWindow *) 0 ;
35277 wxRect *arg2 = 0 ;
35278 bool result;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 wxRect temp2 ;
35282 PyObject * obj0 = 0 ;
35283 PyObject * obj1 = 0 ;
35284 char * kwnames[] = {
35285 (char *) "self",(char *) "rect", NULL
35286 };
35287
35288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35290 if (!SWIG_IsOK(res1)) {
35291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35292 }
35293 arg1 = reinterpret_cast< wxWindow * >(argp1);
35294 {
35295 arg2 = &temp2;
35296 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35297 }
35298 {
35299 PyThreadState* __tstate = wxPyBeginAllowThreads();
35300 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35301 wxPyEndAllowThreads(__tstate);
35302 if (PyErr_Occurred()) SWIG_fail;
35303 }
35304 {
35305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35306 }
35307 return resultobj;
35308 fail:
35309 return NULL;
35310 }
35311
35312
35313 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35314 PyObject *resultobj = 0;
35315 wxWindow *arg1 = (wxWindow *) 0 ;
35316 SwigValueWrapper<wxVisualAttributes > result;
35317 void *argp1 = 0 ;
35318 int res1 = 0 ;
35319 PyObject *swig_obj[1] ;
35320
35321 if (!args) SWIG_fail;
35322 swig_obj[0] = args;
35323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35324 if (!SWIG_IsOK(res1)) {
35325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35326 }
35327 arg1 = reinterpret_cast< wxWindow * >(argp1);
35328 {
35329 PyThreadState* __tstate = wxPyBeginAllowThreads();
35330 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35331 wxPyEndAllowThreads(__tstate);
35332 if (PyErr_Occurred()) SWIG_fail;
35333 }
35334 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35335 return resultobj;
35336 fail:
35337 return NULL;
35338 }
35339
35340
35341 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35342 PyObject *resultobj = 0;
35343 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35344 SwigValueWrapper<wxVisualAttributes > result;
35345 int val1 ;
35346 int ecode1 = 0 ;
35347 PyObject * obj0 = 0 ;
35348 char * kwnames[] = {
35349 (char *) "variant", NULL
35350 };
35351
35352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35353 if (obj0) {
35354 ecode1 = SWIG_AsVal_int(obj0, &val1);
35355 if (!SWIG_IsOK(ecode1)) {
35356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35357 }
35358 arg1 = static_cast< wxWindowVariant >(val1);
35359 }
35360 {
35361 if (!wxPyCheckForApp()) SWIG_fail;
35362 PyThreadState* __tstate = wxPyBeginAllowThreads();
35363 result = wxWindow::GetClassDefaultAttributes(arg1);
35364 wxPyEndAllowThreads(__tstate);
35365 if (PyErr_Occurred()) SWIG_fail;
35366 }
35367 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35368 return resultobj;
35369 fail:
35370 return NULL;
35371 }
35372
35373
35374 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35375 PyObject *resultobj = 0;
35376 wxWindow *arg1 = (wxWindow *) 0 ;
35377 wxColour *arg2 = 0 ;
35378 bool result;
35379 void *argp1 = 0 ;
35380 int res1 = 0 ;
35381 wxColour temp2 ;
35382 PyObject * obj0 = 0 ;
35383 PyObject * obj1 = 0 ;
35384 char * kwnames[] = {
35385 (char *) "self",(char *) "colour", NULL
35386 };
35387
35388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35392 }
35393 arg1 = reinterpret_cast< wxWindow * >(argp1);
35394 {
35395 arg2 = &temp2;
35396 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35397 }
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 {
35405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35406 }
35407 return resultobj;
35408 fail:
35409 return NULL;
35410 }
35411
35412
35413 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35414 PyObject *resultobj = 0;
35415 wxWindow *arg1 = (wxWindow *) 0 ;
35416 wxColour *arg2 = 0 ;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 wxColour temp2 ;
35420 PyObject * obj0 = 0 ;
35421 PyObject * obj1 = 0 ;
35422 char * kwnames[] = {
35423 (char *) "self",(char *) "colour", NULL
35424 };
35425
35426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 {
35433 arg2 = &temp2;
35434 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35435 }
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 resultobj = SWIG_Py_Void();
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35450 PyObject *resultobj = 0;
35451 wxWindow *arg1 = (wxWindow *) 0 ;
35452 wxColour *arg2 = 0 ;
35453 bool result;
35454 void *argp1 = 0 ;
35455 int res1 = 0 ;
35456 wxColour temp2 ;
35457 PyObject * obj0 = 0 ;
35458 PyObject * obj1 = 0 ;
35459 char * kwnames[] = {
35460 (char *) "self",(char *) "colour", NULL
35461 };
35462
35463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35465 if (!SWIG_IsOK(res1)) {
35466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35467 }
35468 arg1 = reinterpret_cast< wxWindow * >(argp1);
35469 {
35470 arg2 = &temp2;
35471 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35472 }
35473 {
35474 PyThreadState* __tstate = wxPyBeginAllowThreads();
35475 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35481 }
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj = 0;
35490 wxWindow *arg1 = (wxWindow *) 0 ;
35491 wxColour *arg2 = 0 ;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 wxColour temp2 ;
35495 PyObject * obj0 = 0 ;
35496 PyObject * obj1 = 0 ;
35497 char * kwnames[] = {
35498 (char *) "self",(char *) "colour", NULL
35499 };
35500
35501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35503 if (!SWIG_IsOK(res1)) {
35504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35505 }
35506 arg1 = reinterpret_cast< wxWindow * >(argp1);
35507 {
35508 arg2 = &temp2;
35509 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35510 }
35511 {
35512 PyThreadState* __tstate = wxPyBeginAllowThreads();
35513 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 resultobj = SWIG_Py_Void();
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35525 PyObject *resultobj = 0;
35526 wxWindow *arg1 = (wxWindow *) 0 ;
35527 wxColour result;
35528 void *argp1 = 0 ;
35529 int res1 = 0 ;
35530 PyObject *swig_obj[1] ;
35531
35532 if (!args) SWIG_fail;
35533 swig_obj[0] = args;
35534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35537 }
35538 arg1 = reinterpret_cast< wxWindow * >(argp1);
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35546 return resultobj;
35547 fail:
35548 return NULL;
35549 }
35550
35551
35552 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35553 PyObject *resultobj = 0;
35554 wxWindow *arg1 = (wxWindow *) 0 ;
35555 wxColour result;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 PyObject *swig_obj[1] ;
35559
35560 if (!args) SWIG_fail;
35561 swig_obj[0] = args;
35562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35563 if (!SWIG_IsOK(res1)) {
35564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35565 }
35566 arg1 = reinterpret_cast< wxWindow * >(argp1);
35567 {
35568 PyThreadState* __tstate = wxPyBeginAllowThreads();
35569 result = ((wxWindow const *)arg1)->GetForegroundColour();
35570 wxPyEndAllowThreads(__tstate);
35571 if (PyErr_Occurred()) SWIG_fail;
35572 }
35573 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35574 return resultobj;
35575 fail:
35576 return NULL;
35577 }
35578
35579
35580 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35581 PyObject *resultobj = 0;
35582 wxWindow *arg1 = (wxWindow *) 0 ;
35583 bool result;
35584 void *argp1 = 0 ;
35585 int res1 = 0 ;
35586 PyObject *swig_obj[1] ;
35587
35588 if (!args) SWIG_fail;
35589 swig_obj[0] = args;
35590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35591 if (!SWIG_IsOK(res1)) {
35592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35593 }
35594 arg1 = reinterpret_cast< wxWindow * >(argp1);
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35598 wxPyEndAllowThreads(__tstate);
35599 if (PyErr_Occurred()) SWIG_fail;
35600 }
35601 {
35602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35603 }
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *resultobj = 0;
35612 wxWindow *arg1 = (wxWindow *) 0 ;
35613 bool result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 PyObject *swig_obj[1] ;
35617
35618 if (!args) SWIG_fail;
35619 swig_obj[0] = args;
35620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35621 if (!SWIG_IsOK(res1)) {
35622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35623 }
35624 arg1 = reinterpret_cast< wxWindow * >(argp1);
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 {
35632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35633 }
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35641 PyObject *resultobj = 0;
35642 wxWindow *arg1 = (wxWindow *) 0 ;
35643 wxBackgroundStyle arg2 ;
35644 bool result;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 int val2 ;
35648 int ecode2 = 0 ;
35649 PyObject * obj0 = 0 ;
35650 PyObject * obj1 = 0 ;
35651 char * kwnames[] = {
35652 (char *) "self",(char *) "style", NULL
35653 };
35654
35655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 ecode2 = SWIG_AsVal_int(obj1, &val2);
35662 if (!SWIG_IsOK(ecode2)) {
35663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35664 }
35665 arg2 = static_cast< wxBackgroundStyle >(val2);
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 {
35673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35674 }
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 wxBackgroundStyle result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 PyObject *swig_obj[1] ;
35688
35689 if (!args) SWIG_fail;
35690 swig_obj[0] = args;
35691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 resultobj = SWIG_From_int(static_cast< int >(result));
35703 return resultobj;
35704 fail:
35705 return NULL;
35706 }
35707
35708
35709 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35710 PyObject *resultobj = 0;
35711 wxWindow *arg1 = (wxWindow *) 0 ;
35712 bool result;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 PyObject *swig_obj[1] ;
35716
35717 if (!args) SWIG_fail;
35718 swig_obj[0] = args;
35719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = (bool)(arg1)->HasTransparentBackground();
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 {
35731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35732 }
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35740 PyObject *resultobj = 0;
35741 wxWindow *arg1 = (wxWindow *) 0 ;
35742 wxCursor *arg2 = 0 ;
35743 bool result;
35744 void *argp1 = 0 ;
35745 int res1 = 0 ;
35746 void *argp2 = 0 ;
35747 int res2 = 0 ;
35748 PyObject * obj0 = 0 ;
35749 PyObject * obj1 = 0 ;
35750 char * kwnames[] = {
35751 (char *) "self",(char *) "cursor", NULL
35752 };
35753
35754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35756 if (!SWIG_IsOK(res1)) {
35757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35758 }
35759 arg1 = reinterpret_cast< wxWindow * >(argp1);
35760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35761 if (!SWIG_IsOK(res2)) {
35762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35763 }
35764 if (!argp2) {
35765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35766 }
35767 arg2 = reinterpret_cast< wxCursor * >(argp2);
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35771 wxPyEndAllowThreads(__tstate);
35772 if (PyErr_Occurred()) SWIG_fail;
35773 }
35774 {
35775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35776 }
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35784 PyObject *resultobj = 0;
35785 wxWindow *arg1 = (wxWindow *) 0 ;
35786 wxCursor result;
35787 void *argp1 = 0 ;
35788 int res1 = 0 ;
35789 PyObject *swig_obj[1] ;
35790
35791 if (!args) SWIG_fail;
35792 swig_obj[0] = args;
35793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35794 if (!SWIG_IsOK(res1)) {
35795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35796 }
35797 arg1 = reinterpret_cast< wxWindow * >(argp1);
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 result = (arg1)->GetCursor();
35801 wxPyEndAllowThreads(__tstate);
35802 if (PyErr_Occurred()) SWIG_fail;
35803 }
35804 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35812 PyObject *resultobj = 0;
35813 wxWindow *arg1 = (wxWindow *) 0 ;
35814 wxFont *arg2 = 0 ;
35815 bool result;
35816 void *argp1 = 0 ;
35817 int res1 = 0 ;
35818 void *argp2 = 0 ;
35819 int res2 = 0 ;
35820 PyObject * obj0 = 0 ;
35821 PyObject * obj1 = 0 ;
35822 char * kwnames[] = {
35823 (char *) "self",(char *) "font", NULL
35824 };
35825
35826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35828 if (!SWIG_IsOK(res1)) {
35829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35830 }
35831 arg1 = reinterpret_cast< wxWindow * >(argp1);
35832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35833 if (!SWIG_IsOK(res2)) {
35834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35835 }
35836 if (!argp2) {
35837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35838 }
35839 arg2 = reinterpret_cast< wxFont * >(argp2);
35840 {
35841 PyThreadState* __tstate = wxPyBeginAllowThreads();
35842 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35843 wxPyEndAllowThreads(__tstate);
35844 if (PyErr_Occurred()) SWIG_fail;
35845 }
35846 {
35847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35848 }
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35856 PyObject *resultobj = 0;
35857 wxWindow *arg1 = (wxWindow *) 0 ;
35858 wxFont *arg2 = 0 ;
35859 void *argp1 = 0 ;
35860 int res1 = 0 ;
35861 void *argp2 = 0 ;
35862 int res2 = 0 ;
35863 PyObject * obj0 = 0 ;
35864 PyObject * obj1 = 0 ;
35865 char * kwnames[] = {
35866 (char *) "self",(char *) "font", NULL
35867 };
35868
35869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35876 if (!SWIG_IsOK(res2)) {
35877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35878 }
35879 if (!argp2) {
35880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35881 }
35882 arg2 = reinterpret_cast< wxFont * >(argp2);
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 (arg1)->SetOwnFont((wxFont const &)*arg2);
35886 wxPyEndAllowThreads(__tstate);
35887 if (PyErr_Occurred()) SWIG_fail;
35888 }
35889 resultobj = SWIG_Py_Void();
35890 return resultobj;
35891 fail:
35892 return NULL;
35893 }
35894
35895
35896 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35897 PyObject *resultobj = 0;
35898 wxWindow *arg1 = (wxWindow *) 0 ;
35899 wxFont result;
35900 void *argp1 = 0 ;
35901 int res1 = 0 ;
35902 PyObject *swig_obj[1] ;
35903
35904 if (!args) SWIG_fail;
35905 swig_obj[0] = args;
35906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35907 if (!SWIG_IsOK(res1)) {
35908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35909 }
35910 arg1 = reinterpret_cast< wxWindow * >(argp1);
35911 {
35912 PyThreadState* __tstate = wxPyBeginAllowThreads();
35913 result = (arg1)->GetFont();
35914 wxPyEndAllowThreads(__tstate);
35915 if (PyErr_Occurred()) SWIG_fail;
35916 }
35917 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35925 PyObject *resultobj = 0;
35926 wxWindow *arg1 = (wxWindow *) 0 ;
35927 wxCaret *arg2 = (wxCaret *) 0 ;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 int res2 = 0 ;
35931 PyObject * obj0 = 0 ;
35932 PyObject * obj1 = 0 ;
35933 char * kwnames[] = {
35934 (char *) "self",(char *) "caret", NULL
35935 };
35936
35937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35939 if (!SWIG_IsOK(res1)) {
35940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35941 }
35942 arg1 = reinterpret_cast< wxWindow * >(argp1);
35943 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35944 if (!SWIG_IsOK(res2)) {
35945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35946 }
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 (arg1)->SetCaret(arg2);
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 resultobj = SWIG_Py_Void();
35954 return resultobj;
35955 fail:
35956 return NULL;
35957 }
35958
35959
35960 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35961 PyObject *resultobj = 0;
35962 wxWindow *arg1 = (wxWindow *) 0 ;
35963 wxCaret *result = 0 ;
35964 void *argp1 = 0 ;
35965 int res1 = 0 ;
35966 PyObject *swig_obj[1] ;
35967
35968 if (!args) SWIG_fail;
35969 swig_obj[0] = args;
35970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35971 if (!SWIG_IsOK(res1)) {
35972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35973 }
35974 arg1 = reinterpret_cast< wxWindow * >(argp1);
35975 {
35976 PyThreadState* __tstate = wxPyBeginAllowThreads();
35977 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35978 wxPyEndAllowThreads(__tstate);
35979 if (PyErr_Occurred()) SWIG_fail;
35980 }
35981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35982 return resultobj;
35983 fail:
35984 return NULL;
35985 }
35986
35987
35988 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35989 PyObject *resultobj = 0;
35990 wxWindow *arg1 = (wxWindow *) 0 ;
35991 int result;
35992 void *argp1 = 0 ;
35993 int res1 = 0 ;
35994 PyObject *swig_obj[1] ;
35995
35996 if (!args) SWIG_fail;
35997 swig_obj[0] = args;
35998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35999 if (!SWIG_IsOK(res1)) {
36000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36001 }
36002 arg1 = reinterpret_cast< wxWindow * >(argp1);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_From_int(static_cast< int >(result));
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 int result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 resultobj = SWIG_From_int(static_cast< int >(result));
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 wxString *arg2 = 0 ;
36048 int *arg3 = (int *) 0 ;
36049 int *arg4 = (int *) 0 ;
36050 void *argp1 = 0 ;
36051 int res1 = 0 ;
36052 bool temp2 = false ;
36053 int temp3 ;
36054 int res3 = SWIG_TMPOBJ ;
36055 int temp4 ;
36056 int res4 = SWIG_TMPOBJ ;
36057 PyObject * obj0 = 0 ;
36058 PyObject * obj1 = 0 ;
36059 char * kwnames[] = {
36060 (char *) "self",(char *) "string", NULL
36061 };
36062
36063 arg3 = &temp3;
36064 arg4 = &temp4;
36065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36067 if (!SWIG_IsOK(res1)) {
36068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36069 }
36070 arg1 = reinterpret_cast< wxWindow * >(argp1);
36071 {
36072 arg2 = wxString_in_helper(obj1);
36073 if (arg2 == NULL) SWIG_fail;
36074 temp2 = true;
36075 }
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36079 wxPyEndAllowThreads(__tstate);
36080 if (PyErr_Occurred()) SWIG_fail;
36081 }
36082 resultobj = SWIG_Py_Void();
36083 if (SWIG_IsTmpObj(res3)) {
36084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36085 } else {
36086 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36088 }
36089 if (SWIG_IsTmpObj(res4)) {
36090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36091 } else {
36092 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36094 }
36095 {
36096 if (temp2)
36097 delete arg2;
36098 }
36099 return resultobj;
36100 fail:
36101 {
36102 if (temp2)
36103 delete arg2;
36104 }
36105 return NULL;
36106 }
36107
36108
36109 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36110 PyObject *resultobj = 0;
36111 wxWindow *arg1 = (wxWindow *) 0 ;
36112 wxString *arg2 = 0 ;
36113 int *arg3 = (int *) 0 ;
36114 int *arg4 = (int *) 0 ;
36115 int *arg5 = (int *) 0 ;
36116 int *arg6 = (int *) 0 ;
36117 wxFont *arg7 = (wxFont *) NULL ;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 bool temp2 = false ;
36121 int temp3 ;
36122 int res3 = SWIG_TMPOBJ ;
36123 int temp4 ;
36124 int res4 = SWIG_TMPOBJ ;
36125 int temp5 ;
36126 int res5 = SWIG_TMPOBJ ;
36127 int temp6 ;
36128 int res6 = SWIG_TMPOBJ ;
36129 void *argp7 = 0 ;
36130 int res7 = 0 ;
36131 PyObject * obj0 = 0 ;
36132 PyObject * obj1 = 0 ;
36133 PyObject * obj2 = 0 ;
36134 char * kwnames[] = {
36135 (char *) "self",(char *) "string",(char *) "font", NULL
36136 };
36137
36138 arg3 = &temp3;
36139 arg4 = &temp4;
36140 arg5 = &temp5;
36141 arg6 = &temp6;
36142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36144 if (!SWIG_IsOK(res1)) {
36145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36146 }
36147 arg1 = reinterpret_cast< wxWindow * >(argp1);
36148 {
36149 arg2 = wxString_in_helper(obj1);
36150 if (arg2 == NULL) SWIG_fail;
36151 temp2 = true;
36152 }
36153 if (obj2) {
36154 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36155 if (!SWIG_IsOK(res7)) {
36156 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36157 }
36158 arg7 = reinterpret_cast< wxFont * >(argp7);
36159 }
36160 {
36161 PyThreadState* __tstate = wxPyBeginAllowThreads();
36162 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36163 wxPyEndAllowThreads(__tstate);
36164 if (PyErr_Occurred()) SWIG_fail;
36165 }
36166 resultobj = SWIG_Py_Void();
36167 if (SWIG_IsTmpObj(res3)) {
36168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36169 } else {
36170 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36172 }
36173 if (SWIG_IsTmpObj(res4)) {
36174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36175 } else {
36176 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36178 }
36179 if (SWIG_IsTmpObj(res5)) {
36180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36181 } else {
36182 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36184 }
36185 if (SWIG_IsTmpObj(res6)) {
36186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36187 } else {
36188 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36190 }
36191 {
36192 if (temp2)
36193 delete arg2;
36194 }
36195 return resultobj;
36196 fail:
36197 {
36198 if (temp2)
36199 delete arg2;
36200 }
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36206 PyObject *resultobj = 0;
36207 wxWindow *arg1 = (wxWindow *) 0 ;
36208 int *arg2 = (int *) 0 ;
36209 int *arg3 = (int *) 0 ;
36210 void *argp1 = 0 ;
36211 int res1 = 0 ;
36212 int temp2 ;
36213 int res2 = 0 ;
36214 int temp3 ;
36215 int res3 = 0 ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 PyObject * obj2 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "x",(char *) "y", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36230 int val;
36231 int ecode = SWIG_AsVal_int(obj1, &val);
36232 if (!SWIG_IsOK(ecode)) {
36233 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36234 }
36235 temp2 = static_cast< int >(val);
36236 arg2 = &temp2;
36237 res2 = SWIG_AddTmpMask(ecode);
36238 }
36239 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36240 int val;
36241 int ecode = SWIG_AsVal_int(obj2, &val);
36242 if (!SWIG_IsOK(ecode)) {
36243 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36244 }
36245 temp3 = static_cast< int >(val);
36246 arg3 = &temp3;
36247 res3 = SWIG_AddTmpMask(ecode);
36248 }
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 if (SWIG_IsTmpObj(res2)) {
36257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36258 } else {
36259 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36260 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36261 }
36262 if (SWIG_IsTmpObj(res3)) {
36263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36264 } else {
36265 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36267 }
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36275 PyObject *resultobj = 0;
36276 wxWindow *arg1 = (wxWindow *) 0 ;
36277 int *arg2 = (int *) 0 ;
36278 int *arg3 = (int *) 0 ;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 int temp2 ;
36282 int res2 = 0 ;
36283 int temp3 ;
36284 int res3 = 0 ;
36285 PyObject * obj0 = 0 ;
36286 PyObject * obj1 = 0 ;
36287 PyObject * obj2 = 0 ;
36288 char * kwnames[] = {
36289 (char *) "self",(char *) "x",(char *) "y", NULL
36290 };
36291
36292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36294 if (!SWIG_IsOK(res1)) {
36295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36296 }
36297 arg1 = reinterpret_cast< wxWindow * >(argp1);
36298 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36299 int val;
36300 int ecode = SWIG_AsVal_int(obj1, &val);
36301 if (!SWIG_IsOK(ecode)) {
36302 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36303 }
36304 temp2 = static_cast< int >(val);
36305 arg2 = &temp2;
36306 res2 = SWIG_AddTmpMask(ecode);
36307 }
36308 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36309 int val;
36310 int ecode = SWIG_AsVal_int(obj2, &val);
36311 if (!SWIG_IsOK(ecode)) {
36312 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36313 }
36314 temp3 = static_cast< int >(val);
36315 arg3 = &temp3;
36316 res3 = SWIG_AddTmpMask(ecode);
36317 }
36318 {
36319 PyThreadState* __tstate = wxPyBeginAllowThreads();
36320 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36321 wxPyEndAllowThreads(__tstate);
36322 if (PyErr_Occurred()) SWIG_fail;
36323 }
36324 resultobj = SWIG_Py_Void();
36325 if (SWIG_IsTmpObj(res2)) {
36326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36327 } else {
36328 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36330 }
36331 if (SWIG_IsTmpObj(res3)) {
36332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36333 } else {
36334 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36336 }
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36344 PyObject *resultobj = 0;
36345 wxWindow *arg1 = (wxWindow *) 0 ;
36346 wxPoint *arg2 = 0 ;
36347 wxPoint result;
36348 void *argp1 = 0 ;
36349 int res1 = 0 ;
36350 wxPoint temp2 ;
36351 PyObject * obj0 = 0 ;
36352 PyObject * obj1 = 0 ;
36353 char * kwnames[] = {
36354 (char *) "self",(char *) "pt", NULL
36355 };
36356
36357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36359 if (!SWIG_IsOK(res1)) {
36360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36361 }
36362 arg1 = reinterpret_cast< wxWindow * >(argp1);
36363 {
36364 arg2 = &temp2;
36365 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36366 }
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36374 return resultobj;
36375 fail:
36376 return NULL;
36377 }
36378
36379
36380 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36381 PyObject *resultobj = 0;
36382 wxWindow *arg1 = (wxWindow *) 0 ;
36383 wxPoint *arg2 = 0 ;
36384 wxPoint result;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 wxPoint temp2 ;
36388 PyObject * obj0 = 0 ;
36389 PyObject * obj1 = 0 ;
36390 char * kwnames[] = {
36391 (char *) "self",(char *) "pt", NULL
36392 };
36393
36394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36396 if (!SWIG_IsOK(res1)) {
36397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36398 }
36399 arg1 = reinterpret_cast< wxWindow * >(argp1);
36400 {
36401 arg2 = &temp2;
36402 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36403 }
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj = 0;
36419 wxWindow *arg1 = (wxWindow *) 0 ;
36420 int arg2 ;
36421 int arg3 ;
36422 wxHitTest result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 int val2 ;
36426 int ecode2 = 0 ;
36427 int val3 ;
36428 int ecode3 = 0 ;
36429 PyObject * obj0 = 0 ;
36430 PyObject * obj1 = 0 ;
36431 PyObject * obj2 = 0 ;
36432 char * kwnames[] = {
36433 (char *) "self",(char *) "x",(char *) "y", NULL
36434 };
36435
36436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36438 if (!SWIG_IsOK(res1)) {
36439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36440 }
36441 arg1 = reinterpret_cast< wxWindow * >(argp1);
36442 ecode2 = SWIG_AsVal_int(obj1, &val2);
36443 if (!SWIG_IsOK(ecode2)) {
36444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36445 }
36446 arg2 = static_cast< int >(val2);
36447 ecode3 = SWIG_AsVal_int(obj2, &val3);
36448 if (!SWIG_IsOK(ecode3)) {
36449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36450 }
36451 arg3 = static_cast< int >(val3);
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 resultobj = SWIG_From_int(static_cast< int >(result));
36459 return resultobj;
36460 fail:
36461 return NULL;
36462 }
36463
36464
36465 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36466 PyObject *resultobj = 0;
36467 wxWindow *arg1 = (wxWindow *) 0 ;
36468 wxPoint *arg2 = 0 ;
36469 wxHitTest result;
36470 void *argp1 = 0 ;
36471 int res1 = 0 ;
36472 wxPoint temp2 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char * kwnames[] = {
36476 (char *) "self",(char *) "pt", NULL
36477 };
36478
36479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",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_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36483 }
36484 arg1 = reinterpret_cast< wxWindow * >(argp1);
36485 {
36486 arg2 = &temp2;
36487 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36488 }
36489 {
36490 PyThreadState* __tstate = wxPyBeginAllowThreads();
36491 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 resultobj = SWIG_From_int(static_cast< int >(result));
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36503 PyObject *resultobj = 0;
36504 wxWindow *arg1 = (wxWindow *) 0 ;
36505 long arg2 ;
36506 wxBorder result;
36507 void *argp1 = 0 ;
36508 int res1 = 0 ;
36509 long val2 ;
36510 int ecode2 = 0 ;
36511
36512 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36514 if (!SWIG_IsOK(res1)) {
36515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36516 }
36517 arg1 = reinterpret_cast< wxWindow * >(argp1);
36518 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36519 if (!SWIG_IsOK(ecode2)) {
36520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36521 }
36522 arg2 = static_cast< long >(val2);
36523 {
36524 PyThreadState* __tstate = wxPyBeginAllowThreads();
36525 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 resultobj = SWIG_From_int(static_cast< int >(result));
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36537 PyObject *resultobj = 0;
36538 wxWindow *arg1 = (wxWindow *) 0 ;
36539 wxBorder result;
36540 void *argp1 = 0 ;
36541 int res1 = 0 ;
36542
36543 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36545 if (!SWIG_IsOK(res1)) {
36546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36547 }
36548 arg1 = reinterpret_cast< wxWindow * >(argp1);
36549 {
36550 PyThreadState* __tstate = wxPyBeginAllowThreads();
36551 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36552 wxPyEndAllowThreads(__tstate);
36553 if (PyErr_Occurred()) SWIG_fail;
36554 }
36555 resultobj = SWIG_From_int(static_cast< int >(result));
36556 return resultobj;
36557 fail:
36558 return NULL;
36559 }
36560
36561
36562 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36563 int argc;
36564 PyObject *argv[3];
36565
36566 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36567 --argc;
36568 if (argc == 1) {
36569 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36570 }
36571 if (argc == 2) {
36572 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36573 }
36574
36575 fail:
36576 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj = 0;
36583 wxWindow *arg1 = (wxWindow *) 0 ;
36584 long arg2 = (long) wxUPDATE_UI_NONE ;
36585 void *argp1 = 0 ;
36586 int res1 = 0 ;
36587 long val2 ;
36588 int ecode2 = 0 ;
36589 PyObject * obj0 = 0 ;
36590 PyObject * obj1 = 0 ;
36591 char * kwnames[] = {
36592 (char *) "self",(char *) "flags", NULL
36593 };
36594
36595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36597 if (!SWIG_IsOK(res1)) {
36598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36599 }
36600 arg1 = reinterpret_cast< wxWindow * >(argp1);
36601 if (obj1) {
36602 ecode2 = SWIG_AsVal_long(obj1, &val2);
36603 if (!SWIG_IsOK(ecode2)) {
36604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36605 }
36606 arg2 = static_cast< long >(val2);
36607 }
36608 {
36609 PyThreadState* __tstate = wxPyBeginAllowThreads();
36610 (arg1)->UpdateWindowUI(arg2);
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 resultobj = SWIG_Py_Void();
36615 return resultobj;
36616 fail:
36617 return NULL;
36618 }
36619
36620
36621 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36622 PyObject *resultobj = 0;
36623 wxWindow *arg1 = (wxWindow *) 0 ;
36624 wxMenu *arg2 = (wxMenu *) 0 ;
36625 int arg3 = (int) -1 ;
36626 int arg4 = (int) -1 ;
36627 bool result;
36628 void *argp1 = 0 ;
36629 int res1 = 0 ;
36630 void *argp2 = 0 ;
36631 int res2 = 0 ;
36632 int val3 ;
36633 int ecode3 = 0 ;
36634 int val4 ;
36635 int ecode4 = 0 ;
36636 PyObject * obj0 = 0 ;
36637 PyObject * obj1 = 0 ;
36638 PyObject * obj2 = 0 ;
36639 PyObject * obj3 = 0 ;
36640 char * kwnames[] = {
36641 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36642 };
36643
36644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36646 if (!SWIG_IsOK(res1)) {
36647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36648 }
36649 arg1 = reinterpret_cast< wxWindow * >(argp1);
36650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36651 if (!SWIG_IsOK(res2)) {
36652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36653 }
36654 arg2 = reinterpret_cast< wxMenu * >(argp2);
36655 if (obj2) {
36656 ecode3 = SWIG_AsVal_int(obj2, &val3);
36657 if (!SWIG_IsOK(ecode3)) {
36658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36659 }
36660 arg3 = static_cast< int >(val3);
36661 }
36662 if (obj3) {
36663 ecode4 = SWIG_AsVal_int(obj3, &val4);
36664 if (!SWIG_IsOK(ecode4)) {
36665 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36666 }
36667 arg4 = static_cast< int >(val4);
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 {
36676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36677 }
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36685 PyObject *resultobj = 0;
36686 wxWindow *arg1 = (wxWindow *) 0 ;
36687 wxMenu *arg2 = (wxMenu *) 0 ;
36688 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36689 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36690 bool result;
36691 void *argp1 = 0 ;
36692 int res1 = 0 ;
36693 void *argp2 = 0 ;
36694 int res2 = 0 ;
36695 wxPoint temp3 ;
36696 PyObject * obj0 = 0 ;
36697 PyObject * obj1 = 0 ;
36698 PyObject * obj2 = 0 ;
36699 char * kwnames[] = {
36700 (char *) "self",(char *) "menu",(char *) "pos", NULL
36701 };
36702
36703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36705 if (!SWIG_IsOK(res1)) {
36706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36707 }
36708 arg1 = reinterpret_cast< wxWindow * >(argp1);
36709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36710 if (!SWIG_IsOK(res2)) {
36711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36712 }
36713 arg2 = reinterpret_cast< wxMenu * >(argp2);
36714 if (obj2) {
36715 {
36716 arg3 = &temp3;
36717 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36718 }
36719 }
36720 {
36721 PyThreadState* __tstate = wxPyBeginAllowThreads();
36722 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 {
36727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36728 }
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36736 PyObject *resultobj = 0;
36737 wxWindow *arg1 = (wxWindow *) 0 ;
36738 bool result;
36739 void *argp1 = 0 ;
36740 int res1 = 0 ;
36741 PyObject *swig_obj[1] ;
36742
36743 if (!args) SWIG_fail;
36744 swig_obj[0] = args;
36745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36748 }
36749 arg1 = reinterpret_cast< wxWindow * >(argp1);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 {
36757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36758 }
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36766 PyObject *resultobj = 0;
36767 wxWindow *arg1 = (wxWindow *) 0 ;
36768 long result;
36769 void *argp1 = 0 ;
36770 int res1 = 0 ;
36771 PyObject *swig_obj[1] ;
36772
36773 if (!args) SWIG_fail;
36774 swig_obj[0] = args;
36775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36776 if (!SWIG_IsOK(res1)) {
36777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36778 }
36779 arg1 = reinterpret_cast< wxWindow * >(argp1);
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 result = (long)wxWindow_GetHandle(arg1);
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 resultobj = SWIG_From_long(static_cast< long >(result));
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36794 PyObject *resultobj = 0;
36795 wxWindow *arg1 = (wxWindow *) 0 ;
36796 long arg2 ;
36797 void *argp1 = 0 ;
36798 int res1 = 0 ;
36799 long val2 ;
36800 int ecode2 = 0 ;
36801 PyObject * obj0 = 0 ;
36802 PyObject * obj1 = 0 ;
36803 char * kwnames[] = {
36804 (char *) "self",(char *) "handle", NULL
36805 };
36806
36807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36809 if (!SWIG_IsOK(res1)) {
36810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36811 }
36812 arg1 = reinterpret_cast< wxWindow * >(argp1);
36813 ecode2 = SWIG_AsVal_long(obj1, &val2);
36814 if (!SWIG_IsOK(ecode2)) {
36815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36816 }
36817 arg2 = static_cast< long >(val2);
36818 {
36819 PyThreadState* __tstate = wxPyBeginAllowThreads();
36820 wxWindow_AssociateHandle(arg1,arg2);
36821 wxPyEndAllowThreads(__tstate);
36822 if (PyErr_Occurred()) SWIG_fail;
36823 }
36824 resultobj = SWIG_Py_Void();
36825 return resultobj;
36826 fail:
36827 return NULL;
36828 }
36829
36830
36831 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36832 PyObject *resultobj = 0;
36833 wxWindow *arg1 = (wxWindow *) 0 ;
36834 void *argp1 = 0 ;
36835 int res1 = 0 ;
36836 PyObject *swig_obj[1] ;
36837
36838 if (!args) SWIG_fail;
36839 swig_obj[0] = args;
36840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36841 if (!SWIG_IsOK(res1)) {
36842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36843 }
36844 arg1 = reinterpret_cast< wxWindow * >(argp1);
36845 {
36846 PyThreadState* __tstate = wxPyBeginAllowThreads();
36847 (arg1)->DissociateHandle();
36848 wxPyEndAllowThreads(__tstate);
36849 if (PyErr_Occurred()) SWIG_fail;
36850 }
36851 resultobj = SWIG_Py_Void();
36852 return resultobj;
36853 fail:
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj = 0;
36860 wxWindow *arg1 = (wxWindow *) 0 ;
36861 int arg2 ;
36862 bool result;
36863 void *argp1 = 0 ;
36864 int res1 = 0 ;
36865 int val2 ;
36866 int ecode2 = 0 ;
36867 PyObject * obj0 = 0 ;
36868 PyObject * obj1 = 0 ;
36869 char * kwnames[] = {
36870 (char *) "self",(char *) "orient", NULL
36871 };
36872
36873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36875 if (!SWIG_IsOK(res1)) {
36876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36877 }
36878 arg1 = reinterpret_cast< wxWindow * >(argp1);
36879 ecode2 = SWIG_AsVal_int(obj1, &val2);
36880 if (!SWIG_IsOK(ecode2)) {
36881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36882 }
36883 arg2 = static_cast< int >(val2);
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 int arg2 ;
36903 int arg3 ;
36904 int arg4 ;
36905 int arg5 ;
36906 bool arg6 = (bool) true ;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 int val2 ;
36910 int ecode2 = 0 ;
36911 int val3 ;
36912 int ecode3 = 0 ;
36913 int val4 ;
36914 int ecode4 = 0 ;
36915 int val5 ;
36916 int ecode5 = 0 ;
36917 bool val6 ;
36918 int ecode6 = 0 ;
36919 PyObject * obj0 = 0 ;
36920 PyObject * obj1 = 0 ;
36921 PyObject * obj2 = 0 ;
36922 PyObject * obj3 = 0 ;
36923 PyObject * obj4 = 0 ;
36924 PyObject * obj5 = 0 ;
36925 char * kwnames[] = {
36926 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36927 };
36928
36929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36931 if (!SWIG_IsOK(res1)) {
36932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36933 }
36934 arg1 = reinterpret_cast< wxWindow * >(argp1);
36935 ecode2 = SWIG_AsVal_int(obj1, &val2);
36936 if (!SWIG_IsOK(ecode2)) {
36937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36938 }
36939 arg2 = static_cast< int >(val2);
36940 ecode3 = SWIG_AsVal_int(obj2, &val3);
36941 if (!SWIG_IsOK(ecode3)) {
36942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36943 }
36944 arg3 = static_cast< int >(val3);
36945 ecode4 = SWIG_AsVal_int(obj3, &val4);
36946 if (!SWIG_IsOK(ecode4)) {
36947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36948 }
36949 arg4 = static_cast< int >(val4);
36950 ecode5 = SWIG_AsVal_int(obj4, &val5);
36951 if (!SWIG_IsOK(ecode5)) {
36952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36953 }
36954 arg5 = static_cast< int >(val5);
36955 if (obj5) {
36956 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36957 if (!SWIG_IsOK(ecode6)) {
36958 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36959 }
36960 arg6 = static_cast< bool >(val6);
36961 }
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 resultobj = SWIG_Py_Void();
36969 return resultobj;
36970 fail:
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36976 PyObject *resultobj = 0;
36977 wxWindow *arg1 = (wxWindow *) 0 ;
36978 int arg2 ;
36979 int arg3 ;
36980 bool arg4 = (bool) true ;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 int val2 ;
36984 int ecode2 = 0 ;
36985 int val3 ;
36986 int ecode3 = 0 ;
36987 bool val4 ;
36988 int ecode4 = 0 ;
36989 PyObject * obj0 = 0 ;
36990 PyObject * obj1 = 0 ;
36991 PyObject * obj2 = 0 ;
36992 PyObject * obj3 = 0 ;
36993 char * kwnames[] = {
36994 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36995 };
36996
36997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36999 if (!SWIG_IsOK(res1)) {
37000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37001 }
37002 arg1 = reinterpret_cast< wxWindow * >(argp1);
37003 ecode2 = SWIG_AsVal_int(obj1, &val2);
37004 if (!SWIG_IsOK(ecode2)) {
37005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37006 }
37007 arg2 = static_cast< int >(val2);
37008 ecode3 = SWIG_AsVal_int(obj2, &val3);
37009 if (!SWIG_IsOK(ecode3)) {
37010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37011 }
37012 arg3 = static_cast< int >(val3);
37013 if (obj3) {
37014 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37015 if (!SWIG_IsOK(ecode4)) {
37016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37017 }
37018 arg4 = static_cast< bool >(val4);
37019 }
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 (arg1)->SetScrollPos(arg2,arg3,arg4);
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_Py_Void();
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj = 0;
37035 wxWindow *arg1 = (wxWindow *) 0 ;
37036 int arg2 ;
37037 int result;
37038 void *argp1 = 0 ;
37039 int res1 = 0 ;
37040 int val2 ;
37041 int ecode2 = 0 ;
37042 PyObject * obj0 = 0 ;
37043 PyObject * obj1 = 0 ;
37044 char * kwnames[] = {
37045 (char *) "self",(char *) "orientation", NULL
37046 };
37047
37048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37050 if (!SWIG_IsOK(res1)) {
37051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37052 }
37053 arg1 = reinterpret_cast< wxWindow * >(argp1);
37054 ecode2 = SWIG_AsVal_int(obj1, &val2);
37055 if (!SWIG_IsOK(ecode2)) {
37056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37057 }
37058 arg2 = static_cast< int >(val2);
37059 {
37060 PyThreadState* __tstate = wxPyBeginAllowThreads();
37061 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37062 wxPyEndAllowThreads(__tstate);
37063 if (PyErr_Occurred()) SWIG_fail;
37064 }
37065 resultobj = SWIG_From_int(static_cast< int >(result));
37066 return resultobj;
37067 fail:
37068 return NULL;
37069 }
37070
37071
37072 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37073 PyObject *resultobj = 0;
37074 wxWindow *arg1 = (wxWindow *) 0 ;
37075 int arg2 ;
37076 int result;
37077 void *argp1 = 0 ;
37078 int res1 = 0 ;
37079 int val2 ;
37080 int ecode2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char * kwnames[] = {
37084 (char *) "self",(char *) "orientation", NULL
37085 };
37086
37087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37091 }
37092 arg1 = reinterpret_cast< wxWindow * >(argp1);
37093 ecode2 = SWIG_AsVal_int(obj1, &val2);
37094 if (!SWIG_IsOK(ecode2)) {
37095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37096 }
37097 arg2 = static_cast< int >(val2);
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 resultobj = SWIG_From_int(static_cast< int >(result));
37105 return resultobj;
37106 fail:
37107 return NULL;
37108 }
37109
37110
37111 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37112 PyObject *resultobj = 0;
37113 wxWindow *arg1 = (wxWindow *) 0 ;
37114 int arg2 ;
37115 int result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 int val2 ;
37119 int ecode2 = 0 ;
37120 PyObject * obj0 = 0 ;
37121 PyObject * obj1 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "orientation", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 ecode2 = SWIG_AsVal_int(obj1, &val2);
37133 if (!SWIG_IsOK(ecode2)) {
37134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37135 }
37136 arg2 = static_cast< int >(val2);
37137 {
37138 PyThreadState* __tstate = wxPyBeginAllowThreads();
37139 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 resultobj = SWIG_From_int(static_cast< int >(result));
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37151 PyObject *resultobj = 0;
37152 wxWindow *arg1 = (wxWindow *) 0 ;
37153 int arg2 ;
37154 int arg3 ;
37155 wxRect *arg4 = (wxRect *) NULL ;
37156 void *argp1 = 0 ;
37157 int res1 = 0 ;
37158 int val2 ;
37159 int ecode2 = 0 ;
37160 int val3 ;
37161 int ecode3 = 0 ;
37162 void *argp4 = 0 ;
37163 int res4 = 0 ;
37164 PyObject * obj0 = 0 ;
37165 PyObject * obj1 = 0 ;
37166 PyObject * obj2 = 0 ;
37167 PyObject * obj3 = 0 ;
37168 char * kwnames[] = {
37169 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37170 };
37171
37172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37174 if (!SWIG_IsOK(res1)) {
37175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37176 }
37177 arg1 = reinterpret_cast< wxWindow * >(argp1);
37178 ecode2 = SWIG_AsVal_int(obj1, &val2);
37179 if (!SWIG_IsOK(ecode2)) {
37180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37181 }
37182 arg2 = static_cast< int >(val2);
37183 ecode3 = SWIG_AsVal_int(obj2, &val3);
37184 if (!SWIG_IsOK(ecode3)) {
37185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37186 }
37187 arg3 = static_cast< int >(val3);
37188 if (obj3) {
37189 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37190 if (!SWIG_IsOK(res4)) {
37191 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37192 }
37193 arg4 = reinterpret_cast< wxRect * >(argp4);
37194 }
37195 {
37196 PyThreadState* __tstate = wxPyBeginAllowThreads();
37197 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37198 wxPyEndAllowThreads(__tstate);
37199 if (PyErr_Occurred()) SWIG_fail;
37200 }
37201 resultobj = SWIG_Py_Void();
37202 return resultobj;
37203 fail:
37204 return NULL;
37205 }
37206
37207
37208 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37209 PyObject *resultobj = 0;
37210 wxWindow *arg1 = (wxWindow *) 0 ;
37211 int arg2 ;
37212 bool result;
37213 void *argp1 = 0 ;
37214 int res1 = 0 ;
37215 int val2 ;
37216 int ecode2 = 0 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "lines", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 ecode2 = SWIG_AsVal_int(obj1, &val2);
37230 if (!SWIG_IsOK(ecode2)) {
37231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37232 }
37233 arg2 = static_cast< int >(val2);
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = (bool)(arg1)->ScrollLines(arg2);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 {
37241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37242 }
37243 return resultobj;
37244 fail:
37245 return NULL;
37246 }
37247
37248
37249 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37250 PyObject *resultobj = 0;
37251 wxWindow *arg1 = (wxWindow *) 0 ;
37252 int arg2 ;
37253 bool result;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 int val2 ;
37257 int ecode2 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 char * kwnames[] = {
37261 (char *) "self",(char *) "pages", NULL
37262 };
37263
37264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37266 if (!SWIG_IsOK(res1)) {
37267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37268 }
37269 arg1 = reinterpret_cast< wxWindow * >(argp1);
37270 ecode2 = SWIG_AsVal_int(obj1, &val2);
37271 if (!SWIG_IsOK(ecode2)) {
37272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37273 }
37274 arg2 = static_cast< int >(val2);
37275 {
37276 PyThreadState* __tstate = wxPyBeginAllowThreads();
37277 result = (bool)(arg1)->ScrollPages(arg2);
37278 wxPyEndAllowThreads(__tstate);
37279 if (PyErr_Occurred()) SWIG_fail;
37280 }
37281 {
37282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37283 }
37284 return resultobj;
37285 fail:
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37291 PyObject *resultobj = 0;
37292 wxWindow *arg1 = (wxWindow *) 0 ;
37293 bool result;
37294 void *argp1 = 0 ;
37295 int res1 = 0 ;
37296 PyObject *swig_obj[1] ;
37297
37298 if (!args) SWIG_fail;
37299 swig_obj[0] = args;
37300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37301 if (!SWIG_IsOK(res1)) {
37302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37303 }
37304 arg1 = reinterpret_cast< wxWindow * >(argp1);
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 result = (bool)(arg1)->LineUp();
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 {
37312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37313 }
37314 return resultobj;
37315 fail:
37316 return NULL;
37317 }
37318
37319
37320 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37321 PyObject *resultobj = 0;
37322 wxWindow *arg1 = (wxWindow *) 0 ;
37323 bool result;
37324 void *argp1 = 0 ;
37325 int res1 = 0 ;
37326 PyObject *swig_obj[1] ;
37327
37328 if (!args) SWIG_fail;
37329 swig_obj[0] = args;
37330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37331 if (!SWIG_IsOK(res1)) {
37332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37333 }
37334 arg1 = reinterpret_cast< wxWindow * >(argp1);
37335 {
37336 PyThreadState* __tstate = wxPyBeginAllowThreads();
37337 result = (bool)(arg1)->LineDown();
37338 wxPyEndAllowThreads(__tstate);
37339 if (PyErr_Occurred()) SWIG_fail;
37340 }
37341 {
37342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37343 }
37344 return resultobj;
37345 fail:
37346 return NULL;
37347 }
37348
37349
37350 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37351 PyObject *resultobj = 0;
37352 wxWindow *arg1 = (wxWindow *) 0 ;
37353 bool result;
37354 void *argp1 = 0 ;
37355 int res1 = 0 ;
37356 PyObject *swig_obj[1] ;
37357
37358 if (!args) SWIG_fail;
37359 swig_obj[0] = args;
37360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37361 if (!SWIG_IsOK(res1)) {
37362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37363 }
37364 arg1 = reinterpret_cast< wxWindow * >(argp1);
37365 {
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 result = (bool)(arg1)->PageUp();
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 {
37372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37373 }
37374 return resultobj;
37375 fail:
37376 return NULL;
37377 }
37378
37379
37380 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37381 PyObject *resultobj = 0;
37382 wxWindow *arg1 = (wxWindow *) 0 ;
37383 bool result;
37384 void *argp1 = 0 ;
37385 int res1 = 0 ;
37386 PyObject *swig_obj[1] ;
37387
37388 if (!args) SWIG_fail;
37389 swig_obj[0] = args;
37390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37391 if (!SWIG_IsOK(res1)) {
37392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37393 }
37394 arg1 = reinterpret_cast< wxWindow * >(argp1);
37395 {
37396 PyThreadState* __tstate = wxPyBeginAllowThreads();
37397 result = (bool)(arg1)->PageDown();
37398 wxPyEndAllowThreads(__tstate);
37399 if (PyErr_Occurred()) SWIG_fail;
37400 }
37401 {
37402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37403 }
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37411 PyObject *resultobj = 0;
37412 wxWindow *arg1 = (wxWindow *) 0 ;
37413 wxString *arg2 = 0 ;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 bool temp2 = false ;
37417 PyObject * obj0 = 0 ;
37418 PyObject * obj1 = 0 ;
37419 char * kwnames[] = {
37420 (char *) "self",(char *) "text", NULL
37421 };
37422
37423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37425 if (!SWIG_IsOK(res1)) {
37426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37427 }
37428 arg1 = reinterpret_cast< wxWindow * >(argp1);
37429 {
37430 arg2 = wxString_in_helper(obj1);
37431 if (arg2 == NULL) SWIG_fail;
37432 temp2 = true;
37433 }
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 (arg1)->SetHelpText((wxString const &)*arg2);
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_Py_Void();
37441 {
37442 if (temp2)
37443 delete arg2;
37444 }
37445 return resultobj;
37446 fail:
37447 {
37448 if (temp2)
37449 delete arg2;
37450 }
37451 return NULL;
37452 }
37453
37454
37455 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37456 PyObject *resultobj = 0;
37457 wxWindow *arg1 = (wxWindow *) 0 ;
37458 wxString *arg2 = 0 ;
37459 void *argp1 = 0 ;
37460 int res1 = 0 ;
37461 bool temp2 = false ;
37462 PyObject * obj0 = 0 ;
37463 PyObject * obj1 = 0 ;
37464 char * kwnames[] = {
37465 (char *) "self",(char *) "text", NULL
37466 };
37467
37468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37470 if (!SWIG_IsOK(res1)) {
37471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37472 }
37473 arg1 = reinterpret_cast< wxWindow * >(argp1);
37474 {
37475 arg2 = wxString_in_helper(obj1);
37476 if (arg2 == NULL) SWIG_fail;
37477 temp2 = true;
37478 }
37479 {
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37482 wxPyEndAllowThreads(__tstate);
37483 if (PyErr_Occurred()) SWIG_fail;
37484 }
37485 resultobj = SWIG_Py_Void();
37486 {
37487 if (temp2)
37488 delete arg2;
37489 }
37490 return resultobj;
37491 fail:
37492 {
37493 if (temp2)
37494 delete arg2;
37495 }
37496 return NULL;
37497 }
37498
37499
37500 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37501 PyObject *resultobj = 0;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 wxPoint *arg2 = 0 ;
37504 wxHelpEvent::Origin arg3 ;
37505 wxString result;
37506 void *argp1 = 0 ;
37507 int res1 = 0 ;
37508 wxPoint temp2 ;
37509 void *argp3 ;
37510 int res3 = 0 ;
37511 PyObject * obj0 = 0 ;
37512 PyObject * obj1 = 0 ;
37513 PyObject * obj2 = 0 ;
37514 char * kwnames[] = {
37515 (char *) "self",(char *) "pt",(char *) "origin", NULL
37516 };
37517
37518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37520 if (!SWIG_IsOK(res1)) {
37521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37522 }
37523 arg1 = reinterpret_cast< wxWindow * >(argp1);
37524 {
37525 arg2 = &temp2;
37526 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37527 }
37528 {
37529 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37530 if (!SWIG_IsOK(res3)) {
37531 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37532 }
37533 if (!argp3) {
37534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37535 } else {
37536 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37537 arg3 = *temp;
37538 if (SWIG_IsNewObj(res3)) delete temp;
37539 }
37540 }
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 #if wxUSE_UNICODE
37549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37550 #else
37551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37552 #endif
37553 }
37554 return resultobj;
37555 fail:
37556 return NULL;
37557 }
37558
37559
37560 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37561 PyObject *resultobj = 0;
37562 wxWindow *arg1 = (wxWindow *) 0 ;
37563 wxString result;
37564 void *argp1 = 0 ;
37565 int res1 = 0 ;
37566 PyObject *swig_obj[1] ;
37567
37568 if (!args) SWIG_fail;
37569 swig_obj[0] = args;
37570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37571 if (!SWIG_IsOK(res1)) {
37572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37573 }
37574 arg1 = reinterpret_cast< wxWindow * >(argp1);
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = ((wxWindow const *)arg1)->GetHelpText();
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 {
37582 #if wxUSE_UNICODE
37583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37584 #else
37585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37586 #endif
37587 }
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37595 PyObject *resultobj = 0;
37596 wxWindow *arg1 = (wxWindow *) 0 ;
37597 wxString *arg2 = 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 bool temp2 = false ;
37601 PyObject * obj0 = 0 ;
37602 PyObject * obj1 = 0 ;
37603 char * kwnames[] = {
37604 (char *) "self",(char *) "tip", NULL
37605 };
37606
37607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37609 if (!SWIG_IsOK(res1)) {
37610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37611 }
37612 arg1 = reinterpret_cast< wxWindow * >(argp1);
37613 {
37614 arg2 = wxString_in_helper(obj1);
37615 if (arg2 == NULL) SWIG_fail;
37616 temp2 = true;
37617 }
37618 {
37619 PyThreadState* __tstate = wxPyBeginAllowThreads();
37620 (arg1)->SetToolTip((wxString const &)*arg2);
37621 wxPyEndAllowThreads(__tstate);
37622 if (PyErr_Occurred()) SWIG_fail;
37623 }
37624 resultobj = SWIG_Py_Void();
37625 {
37626 if (temp2)
37627 delete arg2;
37628 }
37629 return resultobj;
37630 fail:
37631 {
37632 if (temp2)
37633 delete arg2;
37634 }
37635 return NULL;
37636 }
37637
37638
37639 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37640 PyObject *resultobj = 0;
37641 wxWindow *arg1 = (wxWindow *) 0 ;
37642 wxToolTip *arg2 = (wxToolTip *) 0 ;
37643 void *argp1 = 0 ;
37644 int res1 = 0 ;
37645 int res2 = 0 ;
37646 PyObject * obj0 = 0 ;
37647 PyObject * obj1 = 0 ;
37648 char * kwnames[] = {
37649 (char *) "self",(char *) "tip", NULL
37650 };
37651
37652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37654 if (!SWIG_IsOK(res1)) {
37655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37656 }
37657 arg1 = reinterpret_cast< wxWindow * >(argp1);
37658 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37659 if (!SWIG_IsOK(res2)) {
37660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37661 }
37662 {
37663 PyThreadState* __tstate = wxPyBeginAllowThreads();
37664 (arg1)->SetToolTip(arg2);
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 resultobj = SWIG_Py_Void();
37669 return resultobj;
37670 fail:
37671 return NULL;
37672 }
37673
37674
37675 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37676 PyObject *resultobj = 0;
37677 wxWindow *arg1 = (wxWindow *) 0 ;
37678 wxToolTip *result = 0 ;
37679 void *argp1 = 0 ;
37680 int res1 = 0 ;
37681 PyObject *swig_obj[1] ;
37682
37683 if (!args) SWIG_fail;
37684 swig_obj[0] = args;
37685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37686 if (!SWIG_IsOK(res1)) {
37687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37688 }
37689 arg1 = reinterpret_cast< wxWindow * >(argp1);
37690 {
37691 PyThreadState* __tstate = wxPyBeginAllowThreads();
37692 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37693 wxPyEndAllowThreads(__tstate);
37694 if (PyErr_Occurred()) SWIG_fail;
37695 }
37696 {
37697 resultobj = wxPyMake_wxObject(result, (bool)0);
37698 }
37699 return resultobj;
37700 fail:
37701 return NULL;
37702 }
37703
37704
37705 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = 0;
37707 wxWindow *arg1 = (wxWindow *) 0 ;
37708 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37709 void *argp1 = 0 ;
37710 int res1 = 0 ;
37711 int res2 = 0 ;
37712 PyObject * obj0 = 0 ;
37713 PyObject * obj1 = 0 ;
37714 char * kwnames[] = {
37715 (char *) "self",(char *) "dropTarget", NULL
37716 };
37717
37718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37720 if (!SWIG_IsOK(res1)) {
37721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37722 }
37723 arg1 = reinterpret_cast< wxWindow * >(argp1);
37724 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37725 if (!SWIG_IsOK(res2)) {
37726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37727 }
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 (arg1)->SetDropTarget(arg2);
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 resultobj = SWIG_Py_Void();
37735 return resultobj;
37736 fail:
37737 return NULL;
37738 }
37739
37740
37741 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37742 PyObject *resultobj = 0;
37743 wxWindow *arg1 = (wxWindow *) 0 ;
37744 wxPyDropTarget *result = 0 ;
37745 void *argp1 = 0 ;
37746 int res1 = 0 ;
37747 PyObject *swig_obj[1] ;
37748
37749 if (!args) SWIG_fail;
37750 swig_obj[0] = args;
37751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37752 if (!SWIG_IsOK(res1)) {
37753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37754 }
37755 arg1 = reinterpret_cast< wxWindow * >(argp1);
37756 {
37757 PyThreadState* __tstate = wxPyBeginAllowThreads();
37758 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37759 wxPyEndAllowThreads(__tstate);
37760 if (PyErr_Occurred()) SWIG_fail;
37761 }
37762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37763 return resultobj;
37764 fail:
37765 return NULL;
37766 }
37767
37768
37769 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37770 PyObject *resultobj = 0;
37771 wxWindow *arg1 = (wxWindow *) 0 ;
37772 bool arg2 ;
37773 void *argp1 = 0 ;
37774 int res1 = 0 ;
37775 bool val2 ;
37776 int ecode2 = 0 ;
37777 PyObject * obj0 = 0 ;
37778 PyObject * obj1 = 0 ;
37779 char * kwnames[] = {
37780 (char *) "self",(char *) "accept", NULL
37781 };
37782
37783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37785 if (!SWIG_IsOK(res1)) {
37786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37787 }
37788 arg1 = reinterpret_cast< wxWindow * >(argp1);
37789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37790 if (!SWIG_IsOK(ecode2)) {
37791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37792 }
37793 arg2 = static_cast< bool >(val2);
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 wxWindow_DragAcceptFiles(arg1,arg2);
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 resultobj = SWIG_Py_Void();
37801 return resultobj;
37802 fail:
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37808 PyObject *resultobj = 0;
37809 wxWindow *arg1 = (wxWindow *) 0 ;
37810 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 int res2 = 0 ;
37814 PyObject * obj0 = 0 ;
37815 PyObject * obj1 = 0 ;
37816 char * kwnames[] = {
37817 (char *) "self",(char *) "constraints", NULL
37818 };
37819
37820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",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_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37824 }
37825 arg1 = reinterpret_cast< wxWindow * >(argp1);
37826 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37827 if (!SWIG_IsOK(res2)) {
37828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37829 }
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 (arg1)->SetConstraints(arg2);
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 resultobj = SWIG_Py_Void();
37837 return resultobj;
37838 fail:
37839 return NULL;
37840 }
37841
37842
37843 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37844 PyObject *resultobj = 0;
37845 wxWindow *arg1 = (wxWindow *) 0 ;
37846 wxLayoutConstraints *result = 0 ;
37847 void *argp1 = 0 ;
37848 int res1 = 0 ;
37849 PyObject *swig_obj[1] ;
37850
37851 if (!args) SWIG_fail;
37852 swig_obj[0] = args;
37853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37854 if (!SWIG_IsOK(res1)) {
37855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37856 }
37857 arg1 = reinterpret_cast< wxWindow * >(argp1);
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37861 wxPyEndAllowThreads(__tstate);
37862 if (PyErr_Occurred()) SWIG_fail;
37863 }
37864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37872 PyObject *resultobj = 0;
37873 wxWindow *arg1 = (wxWindow *) 0 ;
37874 bool arg2 ;
37875 void *argp1 = 0 ;
37876 int res1 = 0 ;
37877 bool val2 ;
37878 int ecode2 = 0 ;
37879 PyObject * obj0 = 0 ;
37880 PyObject * obj1 = 0 ;
37881 char * kwnames[] = {
37882 (char *) "self",(char *) "autoLayout", NULL
37883 };
37884
37885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37887 if (!SWIG_IsOK(res1)) {
37888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37889 }
37890 arg1 = reinterpret_cast< wxWindow * >(argp1);
37891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37892 if (!SWIG_IsOK(ecode2)) {
37893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37894 }
37895 arg2 = static_cast< bool >(val2);
37896 {
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 (arg1)->SetAutoLayout(arg2);
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = SWIG_Py_Void();
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37910 PyObject *resultobj = 0;
37911 wxWindow *arg1 = (wxWindow *) 0 ;
37912 bool result;
37913 void *argp1 = 0 ;
37914 int res1 = 0 ;
37915 PyObject *swig_obj[1] ;
37916
37917 if (!args) SWIG_fail;
37918 swig_obj[0] = args;
37919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37920 if (!SWIG_IsOK(res1)) {
37921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37922 }
37923 arg1 = reinterpret_cast< wxWindow * >(argp1);
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 {
37931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37932 }
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 bool result;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 PyObject *swig_obj[1] ;
37946
37947 if (!args) SWIG_fail;
37948 swig_obj[0] = args;
37949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37950 if (!SWIG_IsOK(res1)) {
37951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37952 }
37953 arg1 = reinterpret_cast< wxWindow * >(argp1);
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 result = (bool)(arg1)->Layout();
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 {
37961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37962 }
37963 return resultobj;
37964 fail:
37965 return NULL;
37966 }
37967
37968
37969 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37970 PyObject *resultobj = 0;
37971 wxWindow *arg1 = (wxWindow *) 0 ;
37972 wxSizer *arg2 = (wxSizer *) 0 ;
37973 bool arg3 = (bool) true ;
37974 void *argp1 = 0 ;
37975 int res1 = 0 ;
37976 int res2 = 0 ;
37977 bool val3 ;
37978 int ecode3 = 0 ;
37979 PyObject * obj0 = 0 ;
37980 PyObject * obj1 = 0 ;
37981 PyObject * obj2 = 0 ;
37982 char * kwnames[] = {
37983 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37984 };
37985
37986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37988 if (!SWIG_IsOK(res1)) {
37989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37990 }
37991 arg1 = reinterpret_cast< wxWindow * >(argp1);
37992 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37993 if (!SWIG_IsOK(res2)) {
37994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37995 }
37996 if (obj2) {
37997 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37998 if (!SWIG_IsOK(ecode3)) {
37999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38000 }
38001 arg3 = static_cast< bool >(val3);
38002 }
38003 {
38004 PyThreadState* __tstate = wxPyBeginAllowThreads();
38005 (arg1)->SetSizer(arg2,arg3);
38006 wxPyEndAllowThreads(__tstate);
38007 if (PyErr_Occurred()) SWIG_fail;
38008 }
38009 resultobj = SWIG_Py_Void();
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38017 PyObject *resultobj = 0;
38018 wxWindow *arg1 = (wxWindow *) 0 ;
38019 wxSizer *arg2 = (wxSizer *) 0 ;
38020 bool arg3 = (bool) true ;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 int res2 = 0 ;
38024 bool val3 ;
38025 int ecode3 = 0 ;
38026 PyObject * obj0 = 0 ;
38027 PyObject * obj1 = 0 ;
38028 PyObject * obj2 = 0 ;
38029 char * kwnames[] = {
38030 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38031 };
38032
38033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38035 if (!SWIG_IsOK(res1)) {
38036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38037 }
38038 arg1 = reinterpret_cast< wxWindow * >(argp1);
38039 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38040 if (!SWIG_IsOK(res2)) {
38041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38042 }
38043 if (obj2) {
38044 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38045 if (!SWIG_IsOK(ecode3)) {
38046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38047 }
38048 arg3 = static_cast< bool >(val3);
38049 }
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 (arg1)->SetSizerAndFit(arg2,arg3);
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 resultobj = SWIG_Py_Void();
38057 return resultobj;
38058 fail:
38059 return NULL;
38060 }
38061
38062
38063 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38064 PyObject *resultobj = 0;
38065 wxWindow *arg1 = (wxWindow *) 0 ;
38066 wxSizer *result = 0 ;
38067 void *argp1 = 0 ;
38068 int res1 = 0 ;
38069 PyObject *swig_obj[1] ;
38070
38071 if (!args) SWIG_fail;
38072 swig_obj[0] = args;
38073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38074 if (!SWIG_IsOK(res1)) {
38075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38076 }
38077 arg1 = reinterpret_cast< wxWindow * >(argp1);
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38081 wxPyEndAllowThreads(__tstate);
38082 if (PyErr_Occurred()) SWIG_fail;
38083 }
38084 {
38085 resultobj = wxPyMake_wxObject(result, (bool)0);
38086 }
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 wxSizer *arg2 = (wxSizer *) 0 ;
38097 void *argp1 = 0 ;
38098 int res1 = 0 ;
38099 void *argp2 = 0 ;
38100 int res2 = 0 ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "self",(char *) "sizer", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38111 }
38112 arg1 = reinterpret_cast< wxWindow * >(argp1);
38113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38114 if (!SWIG_IsOK(res2)) {
38115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38116 }
38117 arg2 = reinterpret_cast< wxSizer * >(argp2);
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 (arg1)->SetContainingSizer(arg2);
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 resultobj = SWIG_Py_Void();
38125 return resultobj;
38126 fail:
38127 return NULL;
38128 }
38129
38130
38131 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38132 PyObject *resultobj = 0;
38133 wxWindow *arg1 = (wxWindow *) 0 ;
38134 wxSizer *result = 0 ;
38135 void *argp1 = 0 ;
38136 int res1 = 0 ;
38137 PyObject *swig_obj[1] ;
38138
38139 if (!args) SWIG_fail;
38140 swig_obj[0] = args;
38141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38142 if (!SWIG_IsOK(res1)) {
38143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38144 }
38145 arg1 = reinterpret_cast< wxWindow * >(argp1);
38146 {
38147 PyThreadState* __tstate = wxPyBeginAllowThreads();
38148 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38149 wxPyEndAllowThreads(__tstate);
38150 if (PyErr_Occurred()) SWIG_fail;
38151 }
38152 {
38153 resultobj = wxPyMake_wxObject(result, (bool)0);
38154 }
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38162 PyObject *resultobj = 0;
38163 wxWindow *arg1 = (wxWindow *) 0 ;
38164 void *argp1 = 0 ;
38165 int res1 = 0 ;
38166 PyObject *swig_obj[1] ;
38167
38168 if (!args) SWIG_fail;
38169 swig_obj[0] = args;
38170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38171 if (!SWIG_IsOK(res1)) {
38172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38173 }
38174 arg1 = reinterpret_cast< wxWindow * >(argp1);
38175 {
38176 PyThreadState* __tstate = wxPyBeginAllowThreads();
38177 (arg1)->InheritAttributes();
38178 wxPyEndAllowThreads(__tstate);
38179 if (PyErr_Occurred()) SWIG_fail;
38180 }
38181 resultobj = SWIG_Py_Void();
38182 return resultobj;
38183 fail:
38184 return NULL;
38185 }
38186
38187
38188 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38189 PyObject *resultobj = 0;
38190 wxWindow *arg1 = (wxWindow *) 0 ;
38191 bool result;
38192 void *argp1 = 0 ;
38193 int res1 = 0 ;
38194 PyObject *swig_obj[1] ;
38195
38196 if (!args) SWIG_fail;
38197 swig_obj[0] = args;
38198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38199 if (!SWIG_IsOK(res1)) {
38200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38201 }
38202 arg1 = reinterpret_cast< wxWindow * >(argp1);
38203 {
38204 PyThreadState* __tstate = wxPyBeginAllowThreads();
38205 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38206 wxPyEndAllowThreads(__tstate);
38207 if (PyErr_Occurred()) SWIG_fail;
38208 }
38209 {
38210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38211 }
38212 return resultobj;
38213 fail:
38214 return NULL;
38215 }
38216
38217
38218 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38219 PyObject *resultobj = 0;
38220 wxWindow *arg1 = (wxWindow *) 0 ;
38221 bool result;
38222 void *argp1 = 0 ;
38223 int res1 = 0 ;
38224 PyObject *swig_obj[1] ;
38225
38226 if (!args) SWIG_fail;
38227 swig_obj[0] = args;
38228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38231 }
38232 arg1 = reinterpret_cast< wxWindow * >(argp1);
38233 {
38234 PyThreadState* __tstate = wxPyBeginAllowThreads();
38235 result = (bool)(arg1)->CanSetTransparent();
38236 wxPyEndAllowThreads(__tstate);
38237 if (PyErr_Occurred()) SWIG_fail;
38238 }
38239 {
38240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38241 }
38242 return resultobj;
38243 fail:
38244 return NULL;
38245 }
38246
38247
38248 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38249 PyObject *resultobj = 0;
38250 wxWindow *arg1 = (wxWindow *) 0 ;
38251 byte arg2 ;
38252 bool result;
38253 void *argp1 = 0 ;
38254 int res1 = 0 ;
38255 unsigned char val2 ;
38256 int ecode2 = 0 ;
38257 PyObject * obj0 = 0 ;
38258 PyObject * obj1 = 0 ;
38259 char * kwnames[] = {
38260 (char *) "self",(char *) "alpha", NULL
38261 };
38262
38263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38267 }
38268 arg1 = reinterpret_cast< wxWindow * >(argp1);
38269 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38270 if (!SWIG_IsOK(ecode2)) {
38271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38272 }
38273 arg2 = static_cast< byte >(val2);
38274 {
38275 PyThreadState* __tstate = wxPyBeginAllowThreads();
38276 result = (bool)(arg1)->SetTransparent(arg2);
38277 wxPyEndAllowThreads(__tstate);
38278 if (PyErr_Occurred()) SWIG_fail;
38279 }
38280 {
38281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38282 }
38283 return resultobj;
38284 fail:
38285 return NULL;
38286 }
38287
38288
38289 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38290 PyObject *obj;
38291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38292 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38293 return SWIG_Py_Void();
38294 }
38295
38296 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38297 return SWIG_Python_InitShadowInstance(args);
38298 }
38299
38300 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38301 PyObject *resultobj = 0;
38302 long arg1 ;
38303 wxWindow *arg2 = (wxWindow *) NULL ;
38304 wxWindow *result = 0 ;
38305 long val1 ;
38306 int ecode1 = 0 ;
38307 void *argp2 = 0 ;
38308 int res2 = 0 ;
38309 PyObject * obj0 = 0 ;
38310 PyObject * obj1 = 0 ;
38311 char * kwnames[] = {
38312 (char *) "id",(char *) "parent", NULL
38313 };
38314
38315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38316 ecode1 = SWIG_AsVal_long(obj0, &val1);
38317 if (!SWIG_IsOK(ecode1)) {
38318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38319 }
38320 arg1 = static_cast< long >(val1);
38321 if (obj1) {
38322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38323 if (!SWIG_IsOK(res2)) {
38324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38325 }
38326 arg2 = reinterpret_cast< wxWindow * >(argp2);
38327 }
38328 {
38329 if (!wxPyCheckForApp()) SWIG_fail;
38330 PyThreadState* __tstate = wxPyBeginAllowThreads();
38331 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38332 wxPyEndAllowThreads(__tstate);
38333 if (PyErr_Occurred()) SWIG_fail;
38334 }
38335 {
38336 resultobj = wxPyMake_wxObject(result, 0);
38337 }
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38345 PyObject *resultobj = 0;
38346 wxString *arg1 = 0 ;
38347 wxWindow *arg2 = (wxWindow *) NULL ;
38348 wxWindow *result = 0 ;
38349 bool temp1 = false ;
38350 void *argp2 = 0 ;
38351 int res2 = 0 ;
38352 PyObject * obj0 = 0 ;
38353 PyObject * obj1 = 0 ;
38354 char * kwnames[] = {
38355 (char *) "name",(char *) "parent", NULL
38356 };
38357
38358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38359 {
38360 arg1 = wxString_in_helper(obj0);
38361 if (arg1 == NULL) SWIG_fail;
38362 temp1 = true;
38363 }
38364 if (obj1) {
38365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38366 if (!SWIG_IsOK(res2)) {
38367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38368 }
38369 arg2 = reinterpret_cast< wxWindow * >(argp2);
38370 }
38371 {
38372 if (!wxPyCheckForApp()) SWIG_fail;
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 {
38379 resultobj = wxPyMake_wxObject(result, 0);
38380 }
38381 {
38382 if (temp1)
38383 delete arg1;
38384 }
38385 return resultobj;
38386 fail:
38387 {
38388 if (temp1)
38389 delete arg1;
38390 }
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxString *arg1 = 0 ;
38398 wxWindow *arg2 = (wxWindow *) NULL ;
38399 wxWindow *result = 0 ;
38400 bool temp1 = false ;
38401 void *argp2 = 0 ;
38402 int res2 = 0 ;
38403 PyObject * obj0 = 0 ;
38404 PyObject * obj1 = 0 ;
38405 char * kwnames[] = {
38406 (char *) "label",(char *) "parent", NULL
38407 };
38408
38409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38410 {
38411 arg1 = wxString_in_helper(obj0);
38412 if (arg1 == NULL) SWIG_fail;
38413 temp1 = true;
38414 }
38415 if (obj1) {
38416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38417 if (!SWIG_IsOK(res2)) {
38418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38419 }
38420 arg2 = reinterpret_cast< wxWindow * >(argp2);
38421 }
38422 {
38423 if (!wxPyCheckForApp()) SWIG_fail;
38424 PyThreadState* __tstate = wxPyBeginAllowThreads();
38425 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38426 wxPyEndAllowThreads(__tstate);
38427 if (PyErr_Occurred()) SWIG_fail;
38428 }
38429 {
38430 resultobj = wxPyMake_wxObject(result, 0);
38431 }
38432 {
38433 if (temp1)
38434 delete arg1;
38435 }
38436 return resultobj;
38437 fail:
38438 {
38439 if (temp1)
38440 delete arg1;
38441 }
38442 return NULL;
38443 }
38444
38445
38446 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj = 0;
38448 wxWindow *arg1 = (wxWindow *) 0 ;
38449 unsigned long arg2 ;
38450 wxWindow *result = 0 ;
38451 void *argp1 = 0 ;
38452 int res1 = 0 ;
38453 unsigned long val2 ;
38454 int ecode2 = 0 ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 char * kwnames[] = {
38458 (char *) "parent",(char *) "_hWnd", NULL
38459 };
38460
38461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38465 }
38466 arg1 = reinterpret_cast< wxWindow * >(argp1);
38467 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38468 if (!SWIG_IsOK(ecode2)) {
38469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38470 }
38471 arg2 = static_cast< unsigned long >(val2);
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 {
38479 resultobj = wxPyMake_wxObject(result, 0);
38480 }
38481 return resultobj;
38482 fail:
38483 return NULL;
38484 }
38485
38486
38487 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38488 PyObject *resultobj = 0;
38489 PyObject *result = 0 ;
38490
38491 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38492 {
38493 PyThreadState* __tstate = wxPyBeginAllowThreads();
38494 result = (PyObject *)GetTopLevelWindows();
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 resultobj = result;
38499 return resultobj;
38500 fail:
38501 return NULL;
38502 }
38503
38504
38505 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38506 PyObject *resultobj = 0;
38507 wxValidator *result = 0 ;
38508
38509 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 result = (wxValidator *)new wxValidator();
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38517 return resultobj;
38518 fail:
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38524 PyObject *resultobj = 0;
38525 wxValidator *arg1 = (wxValidator *) 0 ;
38526 wxValidator *result = 0 ;
38527 void *argp1 = 0 ;
38528 int res1 = 0 ;
38529 PyObject *swig_obj[1] ;
38530
38531 if (!args) SWIG_fail;
38532 swig_obj[0] = args;
38533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38536 }
38537 arg1 = reinterpret_cast< wxValidator * >(argp1);
38538 {
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 result = (wxValidator *)(arg1)->Clone();
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 {
38545 resultobj = wxPyMake_wxObject(result, 0);
38546 }
38547 return resultobj;
38548 fail:
38549 return NULL;
38550 }
38551
38552
38553 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38554 PyObject *resultobj = 0;
38555 wxValidator *arg1 = (wxValidator *) 0 ;
38556 wxWindow *arg2 = (wxWindow *) 0 ;
38557 bool result;
38558 void *argp1 = 0 ;
38559 int res1 = 0 ;
38560 void *argp2 = 0 ;
38561 int res2 = 0 ;
38562 PyObject * obj0 = 0 ;
38563 PyObject * obj1 = 0 ;
38564 char * kwnames[] = {
38565 (char *) "self",(char *) "parent", NULL
38566 };
38567
38568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38570 if (!SWIG_IsOK(res1)) {
38571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38572 }
38573 arg1 = reinterpret_cast< wxValidator * >(argp1);
38574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38575 if (!SWIG_IsOK(res2)) {
38576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38577 }
38578 arg2 = reinterpret_cast< wxWindow * >(argp2);
38579 {
38580 PyThreadState* __tstate = wxPyBeginAllowThreads();
38581 result = (bool)(arg1)->Validate(arg2);
38582 wxPyEndAllowThreads(__tstate);
38583 if (PyErr_Occurred()) SWIG_fail;
38584 }
38585 {
38586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38587 }
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38595 PyObject *resultobj = 0;
38596 wxValidator *arg1 = (wxValidator *) 0 ;
38597 bool result;
38598 void *argp1 = 0 ;
38599 int res1 = 0 ;
38600 PyObject *swig_obj[1] ;
38601
38602 if (!args) SWIG_fail;
38603 swig_obj[0] = args;
38604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38605 if (!SWIG_IsOK(res1)) {
38606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38607 }
38608 arg1 = reinterpret_cast< wxValidator * >(argp1);
38609 {
38610 PyThreadState* __tstate = wxPyBeginAllowThreads();
38611 result = (bool)(arg1)->TransferToWindow();
38612 wxPyEndAllowThreads(__tstate);
38613 if (PyErr_Occurred()) SWIG_fail;
38614 }
38615 {
38616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38617 }
38618 return resultobj;
38619 fail:
38620 return NULL;
38621 }
38622
38623
38624 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38625 PyObject *resultobj = 0;
38626 wxValidator *arg1 = (wxValidator *) 0 ;
38627 bool result;
38628 void *argp1 = 0 ;
38629 int res1 = 0 ;
38630 PyObject *swig_obj[1] ;
38631
38632 if (!args) SWIG_fail;
38633 swig_obj[0] = args;
38634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38635 if (!SWIG_IsOK(res1)) {
38636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38637 }
38638 arg1 = reinterpret_cast< wxValidator * >(argp1);
38639 {
38640 PyThreadState* __tstate = wxPyBeginAllowThreads();
38641 result = (bool)(arg1)->TransferFromWindow();
38642 wxPyEndAllowThreads(__tstate);
38643 if (PyErr_Occurred()) SWIG_fail;
38644 }
38645 {
38646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38647 }
38648 return resultobj;
38649 fail:
38650 return NULL;
38651 }
38652
38653
38654 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38655 PyObject *resultobj = 0;
38656 wxValidator *arg1 = (wxValidator *) 0 ;
38657 wxWindow *result = 0 ;
38658 void *argp1 = 0 ;
38659 int res1 = 0 ;
38660 PyObject *swig_obj[1] ;
38661
38662 if (!args) SWIG_fail;
38663 swig_obj[0] = args;
38664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38665 if (!SWIG_IsOK(res1)) {
38666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38667 }
38668 arg1 = reinterpret_cast< wxValidator * >(argp1);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = (wxWindow *)(arg1)->GetWindow();
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 {
38676 resultobj = wxPyMake_wxObject(result, 0);
38677 }
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxValidator *arg1 = (wxValidator *) 0 ;
38687 wxWindow *arg2 = (wxWindow *) 0 ;
38688 void *argp1 = 0 ;
38689 int res1 = 0 ;
38690 void *argp2 = 0 ;
38691 int res2 = 0 ;
38692 PyObject * obj0 = 0 ;
38693 PyObject * obj1 = 0 ;
38694 char * kwnames[] = {
38695 (char *) "self",(char *) "window", NULL
38696 };
38697
38698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38700 if (!SWIG_IsOK(res1)) {
38701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38702 }
38703 arg1 = reinterpret_cast< wxValidator * >(argp1);
38704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38705 if (!SWIG_IsOK(res2)) {
38706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38707 }
38708 arg2 = reinterpret_cast< wxWindow * >(argp2);
38709 {
38710 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 (arg1)->SetWindow(arg2);
38712 wxPyEndAllowThreads(__tstate);
38713 if (PyErr_Occurred()) SWIG_fail;
38714 }
38715 resultobj = SWIG_Py_Void();
38716 return resultobj;
38717 fail:
38718 return NULL;
38719 }
38720
38721
38722 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38723 PyObject *resultobj = 0;
38724 bool result;
38725
38726 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38727 {
38728 PyThreadState* __tstate = wxPyBeginAllowThreads();
38729 result = (bool)wxValidator::IsSilent();
38730 wxPyEndAllowThreads(__tstate);
38731 if (PyErr_Occurred()) SWIG_fail;
38732 }
38733 {
38734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38735 }
38736 return resultobj;
38737 fail:
38738 return NULL;
38739 }
38740
38741
38742 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38743 PyObject *resultobj = 0;
38744 int arg1 = (int) true ;
38745 int val1 ;
38746 int ecode1 = 0 ;
38747 PyObject * obj0 = 0 ;
38748 char * kwnames[] = {
38749 (char *) "doIt", NULL
38750 };
38751
38752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38753 if (obj0) {
38754 ecode1 = SWIG_AsVal_int(obj0, &val1);
38755 if (!SWIG_IsOK(ecode1)) {
38756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38757 }
38758 arg1 = static_cast< int >(val1);
38759 }
38760 {
38761 PyThreadState* __tstate = wxPyBeginAllowThreads();
38762 wxValidator::SetBellOnError(arg1);
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 resultobj = SWIG_Py_Void();
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38774 PyObject *obj;
38775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38776 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38777 return SWIG_Py_Void();
38778 }
38779
38780 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38781 return SWIG_Python_InitShadowInstance(args);
38782 }
38783
38784 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38785 PyObject *resultobj = 0;
38786 wxPyValidator *result = 0 ;
38787
38788 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (wxPyValidator *)new wxPyValidator();
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj = 0;
38804 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38805 PyObject *arg2 = (PyObject *) 0 ;
38806 PyObject *arg3 = (PyObject *) 0 ;
38807 int arg4 = (int) true ;
38808 void *argp1 = 0 ;
38809 int res1 = 0 ;
38810 int val4 ;
38811 int ecode4 = 0 ;
38812 PyObject * obj0 = 0 ;
38813 PyObject * obj1 = 0 ;
38814 PyObject * obj2 = 0 ;
38815 PyObject * obj3 = 0 ;
38816 char * kwnames[] = {
38817 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38818 };
38819
38820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38822 if (!SWIG_IsOK(res1)) {
38823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38824 }
38825 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38826 arg2 = obj1;
38827 arg3 = obj2;
38828 if (obj3) {
38829 ecode4 = SWIG_AsVal_int(obj3, &val4);
38830 if (!SWIG_IsOK(ecode4)) {
38831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38832 }
38833 arg4 = static_cast< int >(val4);
38834 }
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38838 wxPyEndAllowThreads(__tstate);
38839 if (PyErr_Occurred()) SWIG_fail;
38840 }
38841 resultobj = SWIG_Py_Void();
38842 return resultobj;
38843 fail:
38844 return NULL;
38845 }
38846
38847
38848 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38849 PyObject *obj;
38850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38851 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38852 return SWIG_Py_Void();
38853 }
38854
38855 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38856 return SWIG_Python_InitShadowInstance(args);
38857 }
38858
38859 SWIGINTERN int DefaultValidator_set(PyObject *) {
38860 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38861 return 1;
38862 }
38863
38864
38865 SWIGINTERN PyObject *DefaultValidator_get(void) {
38866 PyObject *pyobj = 0;
38867
38868 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38869 return pyobj;
38870 }
38871
38872
38873 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38874 PyObject *resultobj = 0;
38875 wxString const &arg1_defvalue = wxPyEmptyString ;
38876 wxString *arg1 = (wxString *) &arg1_defvalue ;
38877 long arg2 = (long) 0 ;
38878 wxMenu *result = 0 ;
38879 bool temp1 = false ;
38880 long val2 ;
38881 int ecode2 = 0 ;
38882 PyObject * obj0 = 0 ;
38883 PyObject * obj1 = 0 ;
38884 char * kwnames[] = {
38885 (char *) "title",(char *) "style", NULL
38886 };
38887
38888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38889 if (obj0) {
38890 {
38891 arg1 = wxString_in_helper(obj0);
38892 if (arg1 == NULL) SWIG_fail;
38893 temp1 = true;
38894 }
38895 }
38896 if (obj1) {
38897 ecode2 = SWIG_AsVal_long(obj1, &val2);
38898 if (!SWIG_IsOK(ecode2)) {
38899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38900 }
38901 arg2 = static_cast< long >(val2);
38902 }
38903 {
38904 if (!wxPyCheckForApp()) SWIG_fail;
38905 PyThreadState* __tstate = wxPyBeginAllowThreads();
38906 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38907 wxPyEndAllowThreads(__tstate);
38908 if (PyErr_Occurred()) SWIG_fail;
38909 }
38910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38911 {
38912 if (temp1)
38913 delete arg1;
38914 }
38915 return resultobj;
38916 fail:
38917 {
38918 if (temp1)
38919 delete arg1;
38920 }
38921 return NULL;
38922 }
38923
38924
38925 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38926 PyObject *resultobj = 0;
38927 wxMenu *arg1 = (wxMenu *) 0 ;
38928 int arg2 ;
38929 wxString const &arg3_defvalue = wxPyEmptyString ;
38930 wxString *arg3 = (wxString *) &arg3_defvalue ;
38931 wxString const &arg4_defvalue = wxPyEmptyString ;
38932 wxString *arg4 = (wxString *) &arg4_defvalue ;
38933 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38934 wxMenuItem *result = 0 ;
38935 void *argp1 = 0 ;
38936 int res1 = 0 ;
38937 int val2 ;
38938 int ecode2 = 0 ;
38939 bool temp3 = false ;
38940 bool temp4 = false ;
38941 int val5 ;
38942 int ecode5 = 0 ;
38943 PyObject * obj0 = 0 ;
38944 PyObject * obj1 = 0 ;
38945 PyObject * obj2 = 0 ;
38946 PyObject * obj3 = 0 ;
38947 PyObject * obj4 = 0 ;
38948 char * kwnames[] = {
38949 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38950 };
38951
38952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38954 if (!SWIG_IsOK(res1)) {
38955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38956 }
38957 arg1 = reinterpret_cast< wxMenu * >(argp1);
38958 ecode2 = SWIG_AsVal_int(obj1, &val2);
38959 if (!SWIG_IsOK(ecode2)) {
38960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38961 }
38962 arg2 = static_cast< int >(val2);
38963 if (obj2) {
38964 {
38965 arg3 = wxString_in_helper(obj2);
38966 if (arg3 == NULL) SWIG_fail;
38967 temp3 = true;
38968 }
38969 }
38970 if (obj3) {
38971 {
38972 arg4 = wxString_in_helper(obj3);
38973 if (arg4 == NULL) SWIG_fail;
38974 temp4 = true;
38975 }
38976 }
38977 if (obj4) {
38978 ecode5 = SWIG_AsVal_int(obj4, &val5);
38979 if (!SWIG_IsOK(ecode5)) {
38980 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38981 }
38982 arg5 = static_cast< wxItemKind >(val5);
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = wxPyMake_wxObject(result, (bool)0);
38992 }
38993 {
38994 if (temp3)
38995 delete arg3;
38996 }
38997 {
38998 if (temp4)
38999 delete arg4;
39000 }
39001 return resultobj;
39002 fail:
39003 {
39004 if (temp3)
39005 delete arg3;
39006 }
39007 {
39008 if (temp4)
39009 delete arg4;
39010 }
39011 return NULL;
39012 }
39013
39014
39015 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39016 PyObject *resultobj = 0;
39017 wxMenu *arg1 = (wxMenu *) 0 ;
39018 wxMenuItem *result = 0 ;
39019 void *argp1 = 0 ;
39020 int res1 = 0 ;
39021 PyObject *swig_obj[1] ;
39022
39023 if (!args) SWIG_fail;
39024 swig_obj[0] = args;
39025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39028 }
39029 arg1 = reinterpret_cast< wxMenu * >(argp1);
39030 {
39031 PyThreadState* __tstate = wxPyBeginAllowThreads();
39032 result = (wxMenuItem *)(arg1)->AppendSeparator();
39033 wxPyEndAllowThreads(__tstate);
39034 if (PyErr_Occurred()) SWIG_fail;
39035 }
39036 {
39037 resultobj = wxPyMake_wxObject(result, (bool)0);
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj = 0;
39047 wxMenu *arg1 = (wxMenu *) 0 ;
39048 int arg2 ;
39049 wxString *arg3 = 0 ;
39050 wxString const &arg4_defvalue = wxPyEmptyString ;
39051 wxString *arg4 = (wxString *) &arg4_defvalue ;
39052 wxMenuItem *result = 0 ;
39053 void *argp1 = 0 ;
39054 int res1 = 0 ;
39055 int val2 ;
39056 int ecode2 = 0 ;
39057 bool temp3 = false ;
39058 bool temp4 = false ;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 PyObject * obj2 = 0 ;
39062 PyObject * obj3 = 0 ;
39063 char * kwnames[] = {
39064 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39065 };
39066
39067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39069 if (!SWIG_IsOK(res1)) {
39070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39071 }
39072 arg1 = reinterpret_cast< wxMenu * >(argp1);
39073 ecode2 = SWIG_AsVal_int(obj1, &val2);
39074 if (!SWIG_IsOK(ecode2)) {
39075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39076 }
39077 arg2 = static_cast< int >(val2);
39078 {
39079 arg3 = wxString_in_helper(obj2);
39080 if (arg3 == NULL) SWIG_fail;
39081 temp3 = true;
39082 }
39083 if (obj3) {
39084 {
39085 arg4 = wxString_in_helper(obj3);
39086 if (arg4 == NULL) SWIG_fail;
39087 temp4 = true;
39088 }
39089 }
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 {
39097 resultobj = wxPyMake_wxObject(result, (bool)0);
39098 }
39099 {
39100 if (temp3)
39101 delete arg3;
39102 }
39103 {
39104 if (temp4)
39105 delete arg4;
39106 }
39107 return resultobj;
39108 fail:
39109 {
39110 if (temp3)
39111 delete arg3;
39112 }
39113 {
39114 if (temp4)
39115 delete arg4;
39116 }
39117 return NULL;
39118 }
39119
39120
39121 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj = 0;
39123 wxMenu *arg1 = (wxMenu *) 0 ;
39124 int arg2 ;
39125 wxString *arg3 = 0 ;
39126 wxString const &arg4_defvalue = wxPyEmptyString ;
39127 wxString *arg4 = (wxString *) &arg4_defvalue ;
39128 wxMenuItem *result = 0 ;
39129 void *argp1 = 0 ;
39130 int res1 = 0 ;
39131 int val2 ;
39132 int ecode2 = 0 ;
39133 bool temp3 = false ;
39134 bool temp4 = false ;
39135 PyObject * obj0 = 0 ;
39136 PyObject * obj1 = 0 ;
39137 PyObject * obj2 = 0 ;
39138 PyObject * obj3 = 0 ;
39139 char * kwnames[] = {
39140 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39141 };
39142
39143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39147 }
39148 arg1 = reinterpret_cast< wxMenu * >(argp1);
39149 ecode2 = SWIG_AsVal_int(obj1, &val2);
39150 if (!SWIG_IsOK(ecode2)) {
39151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39152 }
39153 arg2 = static_cast< int >(val2);
39154 {
39155 arg3 = wxString_in_helper(obj2);
39156 if (arg3 == NULL) SWIG_fail;
39157 temp3 = true;
39158 }
39159 if (obj3) {
39160 {
39161 arg4 = wxString_in_helper(obj3);
39162 if (arg4 == NULL) SWIG_fail;
39163 temp4 = true;
39164 }
39165 }
39166 {
39167 PyThreadState* __tstate = wxPyBeginAllowThreads();
39168 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = wxPyMake_wxObject(result, (bool)0);
39174 }
39175 {
39176 if (temp3)
39177 delete arg3;
39178 }
39179 {
39180 if (temp4)
39181 delete arg4;
39182 }
39183 return resultobj;
39184 fail:
39185 {
39186 if (temp3)
39187 delete arg3;
39188 }
39189 {
39190 if (temp4)
39191 delete arg4;
39192 }
39193 return NULL;
39194 }
39195
39196
39197 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj = 0;
39199 wxMenu *arg1 = (wxMenu *) 0 ;
39200 int arg2 ;
39201 wxString *arg3 = 0 ;
39202 wxMenu *arg4 = (wxMenu *) 0 ;
39203 wxString const &arg5_defvalue = wxPyEmptyString ;
39204 wxString *arg5 = (wxString *) &arg5_defvalue ;
39205 wxMenuItem *result = 0 ;
39206 void *argp1 = 0 ;
39207 int res1 = 0 ;
39208 int val2 ;
39209 int ecode2 = 0 ;
39210 bool temp3 = false ;
39211 void *argp4 = 0 ;
39212 int res4 = 0 ;
39213 bool temp5 = false ;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 PyObject * obj2 = 0 ;
39217 PyObject * obj3 = 0 ;
39218 PyObject * obj4 = 0 ;
39219 char * kwnames[] = {
39220 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39221 };
39222
39223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39225 if (!SWIG_IsOK(res1)) {
39226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39227 }
39228 arg1 = reinterpret_cast< wxMenu * >(argp1);
39229 ecode2 = SWIG_AsVal_int(obj1, &val2);
39230 if (!SWIG_IsOK(ecode2)) {
39231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39232 }
39233 arg2 = static_cast< int >(val2);
39234 {
39235 arg3 = wxString_in_helper(obj2);
39236 if (arg3 == NULL) SWIG_fail;
39237 temp3 = true;
39238 }
39239 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39240 if (!SWIG_IsOK(res4)) {
39241 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39242 }
39243 arg4 = reinterpret_cast< wxMenu * >(argp4);
39244 if (obj4) {
39245 {
39246 arg5 = wxString_in_helper(obj4);
39247 if (arg5 == NULL) SWIG_fail;
39248 temp5 = true;
39249 }
39250 }
39251 {
39252 PyThreadState* __tstate = wxPyBeginAllowThreads();
39253 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39254 wxPyEndAllowThreads(__tstate);
39255 if (PyErr_Occurred()) SWIG_fail;
39256 }
39257 {
39258 resultobj = wxPyMake_wxObject(result, (bool)0);
39259 }
39260 {
39261 if (temp3)
39262 delete arg3;
39263 }
39264 {
39265 if (temp5)
39266 delete arg5;
39267 }
39268 return resultobj;
39269 fail:
39270 {
39271 if (temp3)
39272 delete arg3;
39273 }
39274 {
39275 if (temp5)
39276 delete arg5;
39277 }
39278 return NULL;
39279 }
39280
39281
39282 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39283 PyObject *resultobj = 0;
39284 wxMenu *arg1 = (wxMenu *) 0 ;
39285 wxMenu *arg2 = (wxMenu *) 0 ;
39286 wxString *arg3 = 0 ;
39287 wxString const &arg4_defvalue = wxPyEmptyString ;
39288 wxString *arg4 = (wxString *) &arg4_defvalue ;
39289 wxMenuItem *result = 0 ;
39290 void *argp1 = 0 ;
39291 int res1 = 0 ;
39292 void *argp2 = 0 ;
39293 int res2 = 0 ;
39294 bool temp3 = false ;
39295 bool temp4 = false ;
39296 PyObject * obj0 = 0 ;
39297 PyObject * obj1 = 0 ;
39298 PyObject * obj2 = 0 ;
39299 PyObject * obj3 = 0 ;
39300 char * kwnames[] = {
39301 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39302 };
39303
39304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39306 if (!SWIG_IsOK(res1)) {
39307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39308 }
39309 arg1 = reinterpret_cast< wxMenu * >(argp1);
39310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39311 if (!SWIG_IsOK(res2)) {
39312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39313 }
39314 arg2 = reinterpret_cast< wxMenu * >(argp2);
39315 {
39316 arg3 = wxString_in_helper(obj2);
39317 if (arg3 == NULL) SWIG_fail;
39318 temp3 = true;
39319 }
39320 if (obj3) {
39321 {
39322 arg4 = wxString_in_helper(obj3);
39323 if (arg4 == NULL) SWIG_fail;
39324 temp4 = true;
39325 }
39326 }
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 {
39334 resultobj = wxPyMake_wxObject(result, (bool)0);
39335 }
39336 {
39337 if (temp3)
39338 delete arg3;
39339 }
39340 {
39341 if (temp4)
39342 delete arg4;
39343 }
39344 return resultobj;
39345 fail:
39346 {
39347 if (temp3)
39348 delete arg3;
39349 }
39350 {
39351 if (temp4)
39352 delete arg4;
39353 }
39354 return NULL;
39355 }
39356
39357
39358 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39359 PyObject *resultobj = 0;
39360 wxMenu *arg1 = (wxMenu *) 0 ;
39361 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39362 wxMenuItem *result = 0 ;
39363 void *argp1 = 0 ;
39364 int res1 = 0 ;
39365 int res2 = 0 ;
39366 PyObject * obj0 = 0 ;
39367 PyObject * obj1 = 0 ;
39368 char * kwnames[] = {
39369 (char *) "self",(char *) "item", NULL
39370 };
39371
39372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39374 if (!SWIG_IsOK(res1)) {
39375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39376 }
39377 arg1 = reinterpret_cast< wxMenu * >(argp1);
39378 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39379 if (!SWIG_IsOK(res2)) {
39380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39381 }
39382 {
39383 PyThreadState* __tstate = wxPyBeginAllowThreads();
39384 result = (wxMenuItem *)(arg1)->Append(arg2);
39385 wxPyEndAllowThreads(__tstate);
39386 if (PyErr_Occurred()) SWIG_fail;
39387 }
39388 {
39389 resultobj = wxPyMake_wxObject(result, (bool)0);
39390 }
39391 return resultobj;
39392 fail:
39393 return NULL;
39394 }
39395
39396
39397 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39398 PyObject *resultobj = 0;
39399 wxMenu *arg1 = (wxMenu *) 0 ;
39400 size_t arg2 ;
39401 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39402 wxMenuItem *result = 0 ;
39403 void *argp1 = 0 ;
39404 int res1 = 0 ;
39405 size_t val2 ;
39406 int ecode2 = 0 ;
39407 int res3 = 0 ;
39408 PyObject * obj0 = 0 ;
39409 PyObject * obj1 = 0 ;
39410 PyObject * obj2 = 0 ;
39411 char * kwnames[] = {
39412 (char *) "self",(char *) "pos",(char *) "item", NULL
39413 };
39414
39415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39417 if (!SWIG_IsOK(res1)) {
39418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39419 }
39420 arg1 = reinterpret_cast< wxMenu * >(argp1);
39421 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39422 if (!SWIG_IsOK(ecode2)) {
39423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39424 }
39425 arg2 = static_cast< size_t >(val2);
39426 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39427 if (!SWIG_IsOK(res3)) {
39428 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39429 }
39430 {
39431 PyThreadState* __tstate = wxPyBeginAllowThreads();
39432 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39433 wxPyEndAllowThreads(__tstate);
39434 if (PyErr_Occurred()) SWIG_fail;
39435 }
39436 {
39437 resultobj = wxPyMake_wxObject(result, (bool)0);
39438 }
39439 return resultobj;
39440 fail:
39441 return NULL;
39442 }
39443
39444
39445 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39446 PyObject *resultobj = 0;
39447 wxMenu *arg1 = (wxMenu *) 0 ;
39448 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39449 wxMenuItem *result = 0 ;
39450 void *argp1 = 0 ;
39451 int res1 = 0 ;
39452 int res2 = 0 ;
39453 PyObject * obj0 = 0 ;
39454 PyObject * obj1 = 0 ;
39455 char * kwnames[] = {
39456 (char *) "self",(char *) "item", NULL
39457 };
39458
39459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39461 if (!SWIG_IsOK(res1)) {
39462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39463 }
39464 arg1 = reinterpret_cast< wxMenu * >(argp1);
39465 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39466 if (!SWIG_IsOK(res2)) {
39467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39468 }
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 {
39476 resultobj = wxPyMake_wxObject(result, (bool)0);
39477 }
39478 return resultobj;
39479 fail:
39480 return NULL;
39481 }
39482
39483
39484 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39485 PyObject *resultobj = 0;
39486 wxMenu *arg1 = (wxMenu *) 0 ;
39487 void *argp1 = 0 ;
39488 int res1 = 0 ;
39489 PyObject *swig_obj[1] ;
39490
39491 if (!args) SWIG_fail;
39492 swig_obj[0] = args;
39493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39494 if (!SWIG_IsOK(res1)) {
39495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39496 }
39497 arg1 = reinterpret_cast< wxMenu * >(argp1);
39498 {
39499 PyThreadState* __tstate = wxPyBeginAllowThreads();
39500 (arg1)->Break();
39501 wxPyEndAllowThreads(__tstate);
39502 if (PyErr_Occurred()) SWIG_fail;
39503 }
39504 resultobj = SWIG_Py_Void();
39505 return resultobj;
39506 fail:
39507 return NULL;
39508 }
39509
39510
39511 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39512 PyObject *resultobj = 0;
39513 wxMenu *arg1 = (wxMenu *) 0 ;
39514 size_t arg2 ;
39515 int arg3 ;
39516 wxString const &arg4_defvalue = wxPyEmptyString ;
39517 wxString *arg4 = (wxString *) &arg4_defvalue ;
39518 wxString const &arg5_defvalue = wxPyEmptyString ;
39519 wxString *arg5 = (wxString *) &arg5_defvalue ;
39520 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39521 wxMenuItem *result = 0 ;
39522 void *argp1 = 0 ;
39523 int res1 = 0 ;
39524 size_t val2 ;
39525 int ecode2 = 0 ;
39526 int val3 ;
39527 int ecode3 = 0 ;
39528 bool temp4 = false ;
39529 bool temp5 = false ;
39530 int val6 ;
39531 int ecode6 = 0 ;
39532 PyObject * obj0 = 0 ;
39533 PyObject * obj1 = 0 ;
39534 PyObject * obj2 = 0 ;
39535 PyObject * obj3 = 0 ;
39536 PyObject * obj4 = 0 ;
39537 PyObject * obj5 = 0 ;
39538 char * kwnames[] = {
39539 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39540 };
39541
39542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39544 if (!SWIG_IsOK(res1)) {
39545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39546 }
39547 arg1 = reinterpret_cast< wxMenu * >(argp1);
39548 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39549 if (!SWIG_IsOK(ecode2)) {
39550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39551 }
39552 arg2 = static_cast< size_t >(val2);
39553 ecode3 = SWIG_AsVal_int(obj2, &val3);
39554 if (!SWIG_IsOK(ecode3)) {
39555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39556 }
39557 arg3 = static_cast< int >(val3);
39558 if (obj3) {
39559 {
39560 arg4 = wxString_in_helper(obj3);
39561 if (arg4 == NULL) SWIG_fail;
39562 temp4 = true;
39563 }
39564 }
39565 if (obj4) {
39566 {
39567 arg5 = wxString_in_helper(obj4);
39568 if (arg5 == NULL) SWIG_fail;
39569 temp5 = true;
39570 }
39571 }
39572 if (obj5) {
39573 ecode6 = SWIG_AsVal_int(obj5, &val6);
39574 if (!SWIG_IsOK(ecode6)) {
39575 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39576 }
39577 arg6 = static_cast< wxItemKind >(val6);
39578 }
39579 {
39580 PyThreadState* __tstate = wxPyBeginAllowThreads();
39581 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39582 wxPyEndAllowThreads(__tstate);
39583 if (PyErr_Occurred()) SWIG_fail;
39584 }
39585 {
39586 resultobj = wxPyMake_wxObject(result, (bool)0);
39587 }
39588 {
39589 if (temp4)
39590 delete arg4;
39591 }
39592 {
39593 if (temp5)
39594 delete arg5;
39595 }
39596 return resultobj;
39597 fail:
39598 {
39599 if (temp4)
39600 delete arg4;
39601 }
39602 {
39603 if (temp5)
39604 delete arg5;
39605 }
39606 return NULL;
39607 }
39608
39609
39610 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj = 0;
39612 wxMenu *arg1 = (wxMenu *) 0 ;
39613 size_t arg2 ;
39614 wxMenuItem *result = 0 ;
39615 void *argp1 = 0 ;
39616 int res1 = 0 ;
39617 size_t val2 ;
39618 int ecode2 = 0 ;
39619 PyObject * obj0 = 0 ;
39620 PyObject * obj1 = 0 ;
39621 char * kwnames[] = {
39622 (char *) "self",(char *) "pos", NULL
39623 };
39624
39625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39627 if (!SWIG_IsOK(res1)) {
39628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39629 }
39630 arg1 = reinterpret_cast< wxMenu * >(argp1);
39631 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39632 if (!SWIG_IsOK(ecode2)) {
39633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39634 }
39635 arg2 = static_cast< size_t >(val2);
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 {
39643 resultobj = wxPyMake_wxObject(result, (bool)0);
39644 }
39645 return resultobj;
39646 fail:
39647 return NULL;
39648 }
39649
39650
39651 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39652 PyObject *resultobj = 0;
39653 wxMenu *arg1 = (wxMenu *) 0 ;
39654 size_t arg2 ;
39655 int arg3 ;
39656 wxString *arg4 = 0 ;
39657 wxString const &arg5_defvalue = wxPyEmptyString ;
39658 wxString *arg5 = (wxString *) &arg5_defvalue ;
39659 wxMenuItem *result = 0 ;
39660 void *argp1 = 0 ;
39661 int res1 = 0 ;
39662 size_t val2 ;
39663 int ecode2 = 0 ;
39664 int val3 ;
39665 int ecode3 = 0 ;
39666 bool temp4 = false ;
39667 bool temp5 = false ;
39668 PyObject * obj0 = 0 ;
39669 PyObject * obj1 = 0 ;
39670 PyObject * obj2 = 0 ;
39671 PyObject * obj3 = 0 ;
39672 PyObject * obj4 = 0 ;
39673 char * kwnames[] = {
39674 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39675 };
39676
39677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39679 if (!SWIG_IsOK(res1)) {
39680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39681 }
39682 arg1 = reinterpret_cast< wxMenu * >(argp1);
39683 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39684 if (!SWIG_IsOK(ecode2)) {
39685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39686 }
39687 arg2 = static_cast< size_t >(val2);
39688 ecode3 = SWIG_AsVal_int(obj2, &val3);
39689 if (!SWIG_IsOK(ecode3)) {
39690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39691 }
39692 arg3 = static_cast< int >(val3);
39693 {
39694 arg4 = wxString_in_helper(obj3);
39695 if (arg4 == NULL) SWIG_fail;
39696 temp4 = true;
39697 }
39698 if (obj4) {
39699 {
39700 arg5 = wxString_in_helper(obj4);
39701 if (arg5 == NULL) SWIG_fail;
39702 temp5 = true;
39703 }
39704 }
39705 {
39706 PyThreadState* __tstate = wxPyBeginAllowThreads();
39707 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39708 wxPyEndAllowThreads(__tstate);
39709 if (PyErr_Occurred()) SWIG_fail;
39710 }
39711 {
39712 resultobj = wxPyMake_wxObject(result, (bool)0);
39713 }
39714 {
39715 if (temp4)
39716 delete arg4;
39717 }
39718 {
39719 if (temp5)
39720 delete arg5;
39721 }
39722 return resultobj;
39723 fail:
39724 {
39725 if (temp4)
39726 delete arg4;
39727 }
39728 {
39729 if (temp5)
39730 delete arg5;
39731 }
39732 return NULL;
39733 }
39734
39735
39736 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj = 0;
39738 wxMenu *arg1 = (wxMenu *) 0 ;
39739 size_t arg2 ;
39740 int arg3 ;
39741 wxString *arg4 = 0 ;
39742 wxString const &arg5_defvalue = wxPyEmptyString ;
39743 wxString *arg5 = (wxString *) &arg5_defvalue ;
39744 wxMenuItem *result = 0 ;
39745 void *argp1 = 0 ;
39746 int res1 = 0 ;
39747 size_t val2 ;
39748 int ecode2 = 0 ;
39749 int val3 ;
39750 int ecode3 = 0 ;
39751 bool temp4 = false ;
39752 bool temp5 = false ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 PyObject * obj2 = 0 ;
39756 PyObject * obj3 = 0 ;
39757 PyObject * obj4 = 0 ;
39758 char * kwnames[] = {
39759 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39760 };
39761
39762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39764 if (!SWIG_IsOK(res1)) {
39765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39766 }
39767 arg1 = reinterpret_cast< wxMenu * >(argp1);
39768 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39769 if (!SWIG_IsOK(ecode2)) {
39770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39771 }
39772 arg2 = static_cast< size_t >(val2);
39773 ecode3 = SWIG_AsVal_int(obj2, &val3);
39774 if (!SWIG_IsOK(ecode3)) {
39775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39776 }
39777 arg3 = static_cast< int >(val3);
39778 {
39779 arg4 = wxString_in_helper(obj3);
39780 if (arg4 == NULL) SWIG_fail;
39781 temp4 = true;
39782 }
39783 if (obj4) {
39784 {
39785 arg5 = wxString_in_helper(obj4);
39786 if (arg5 == NULL) SWIG_fail;
39787 temp5 = true;
39788 }
39789 }
39790 {
39791 PyThreadState* __tstate = wxPyBeginAllowThreads();
39792 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 {
39797 resultobj = wxPyMake_wxObject(result, (bool)0);
39798 }
39799 {
39800 if (temp4)
39801 delete arg4;
39802 }
39803 {
39804 if (temp5)
39805 delete arg5;
39806 }
39807 return resultobj;
39808 fail:
39809 {
39810 if (temp4)
39811 delete arg4;
39812 }
39813 {
39814 if (temp5)
39815 delete arg5;
39816 }
39817 return NULL;
39818 }
39819
39820
39821 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39822 PyObject *resultobj = 0;
39823 wxMenu *arg1 = (wxMenu *) 0 ;
39824 size_t arg2 ;
39825 int arg3 ;
39826 wxString *arg4 = 0 ;
39827 wxMenu *arg5 = (wxMenu *) 0 ;
39828 wxString const &arg6_defvalue = wxPyEmptyString ;
39829 wxString *arg6 = (wxString *) &arg6_defvalue ;
39830 wxMenuItem *result = 0 ;
39831 void *argp1 = 0 ;
39832 int res1 = 0 ;
39833 size_t val2 ;
39834 int ecode2 = 0 ;
39835 int val3 ;
39836 int ecode3 = 0 ;
39837 bool temp4 = false ;
39838 void *argp5 = 0 ;
39839 int res5 = 0 ;
39840 bool temp6 = false ;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 PyObject * obj2 = 0 ;
39844 PyObject * obj3 = 0 ;
39845 PyObject * obj4 = 0 ;
39846 PyObject * obj5 = 0 ;
39847 char * kwnames[] = {
39848 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39849 };
39850
39851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39853 if (!SWIG_IsOK(res1)) {
39854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39855 }
39856 arg1 = reinterpret_cast< wxMenu * >(argp1);
39857 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39858 if (!SWIG_IsOK(ecode2)) {
39859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39860 }
39861 arg2 = static_cast< size_t >(val2);
39862 ecode3 = SWIG_AsVal_int(obj2, &val3);
39863 if (!SWIG_IsOK(ecode3)) {
39864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39865 }
39866 arg3 = static_cast< int >(val3);
39867 {
39868 arg4 = wxString_in_helper(obj3);
39869 if (arg4 == NULL) SWIG_fail;
39870 temp4 = true;
39871 }
39872 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39873 if (!SWIG_IsOK(res5)) {
39874 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39875 }
39876 arg5 = reinterpret_cast< wxMenu * >(argp5);
39877 if (obj5) {
39878 {
39879 arg6 = wxString_in_helper(obj5);
39880 if (arg6 == NULL) SWIG_fail;
39881 temp6 = true;
39882 }
39883 }
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = wxPyMake_wxObject(result, (bool)0);
39892 }
39893 {
39894 if (temp4)
39895 delete arg4;
39896 }
39897 {
39898 if (temp6)
39899 delete arg6;
39900 }
39901 return resultobj;
39902 fail:
39903 {
39904 if (temp4)
39905 delete arg4;
39906 }
39907 {
39908 if (temp6)
39909 delete arg6;
39910 }
39911 return NULL;
39912 }
39913
39914
39915 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj = 0;
39917 wxMenu *arg1 = (wxMenu *) 0 ;
39918 int arg2 ;
39919 wxString const &arg3_defvalue = wxPyEmptyString ;
39920 wxString *arg3 = (wxString *) &arg3_defvalue ;
39921 wxString const &arg4_defvalue = wxPyEmptyString ;
39922 wxString *arg4 = (wxString *) &arg4_defvalue ;
39923 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39924 wxMenuItem *result = 0 ;
39925 void *argp1 = 0 ;
39926 int res1 = 0 ;
39927 int val2 ;
39928 int ecode2 = 0 ;
39929 bool temp3 = false ;
39930 bool temp4 = false ;
39931 int val5 ;
39932 int ecode5 = 0 ;
39933 PyObject * obj0 = 0 ;
39934 PyObject * obj1 = 0 ;
39935 PyObject * obj2 = 0 ;
39936 PyObject * obj3 = 0 ;
39937 PyObject * obj4 = 0 ;
39938 char * kwnames[] = {
39939 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39940 };
39941
39942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39944 if (!SWIG_IsOK(res1)) {
39945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39946 }
39947 arg1 = reinterpret_cast< wxMenu * >(argp1);
39948 ecode2 = SWIG_AsVal_int(obj1, &val2);
39949 if (!SWIG_IsOK(ecode2)) {
39950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39951 }
39952 arg2 = static_cast< int >(val2);
39953 if (obj2) {
39954 {
39955 arg3 = wxString_in_helper(obj2);
39956 if (arg3 == NULL) SWIG_fail;
39957 temp3 = true;
39958 }
39959 }
39960 if (obj3) {
39961 {
39962 arg4 = wxString_in_helper(obj3);
39963 if (arg4 == NULL) SWIG_fail;
39964 temp4 = true;
39965 }
39966 }
39967 if (obj4) {
39968 ecode5 = SWIG_AsVal_int(obj4, &val5);
39969 if (!SWIG_IsOK(ecode5)) {
39970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39971 }
39972 arg5 = static_cast< wxItemKind >(val5);
39973 }
39974 {
39975 PyThreadState* __tstate = wxPyBeginAllowThreads();
39976 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39977 wxPyEndAllowThreads(__tstate);
39978 if (PyErr_Occurred()) SWIG_fail;
39979 }
39980 {
39981 resultobj = wxPyMake_wxObject(result, (bool)0);
39982 }
39983 {
39984 if (temp3)
39985 delete arg3;
39986 }
39987 {
39988 if (temp4)
39989 delete arg4;
39990 }
39991 return resultobj;
39992 fail:
39993 {
39994 if (temp3)
39995 delete arg3;
39996 }
39997 {
39998 if (temp4)
39999 delete arg4;
40000 }
40001 return NULL;
40002 }
40003
40004
40005 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40006 PyObject *resultobj = 0;
40007 wxMenu *arg1 = (wxMenu *) 0 ;
40008 wxMenuItem *result = 0 ;
40009 void *argp1 = 0 ;
40010 int res1 = 0 ;
40011 PyObject *swig_obj[1] ;
40012
40013 if (!args) SWIG_fail;
40014 swig_obj[0] = args;
40015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40016 if (!SWIG_IsOK(res1)) {
40017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40018 }
40019 arg1 = reinterpret_cast< wxMenu * >(argp1);
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 result = (wxMenuItem *)(arg1)->PrependSeparator();
40023 wxPyEndAllowThreads(__tstate);
40024 if (PyErr_Occurred()) SWIG_fail;
40025 }
40026 {
40027 resultobj = wxPyMake_wxObject(result, (bool)0);
40028 }
40029 return resultobj;
40030 fail:
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40036 PyObject *resultobj = 0;
40037 wxMenu *arg1 = (wxMenu *) 0 ;
40038 int arg2 ;
40039 wxString *arg3 = 0 ;
40040 wxString const &arg4_defvalue = wxPyEmptyString ;
40041 wxString *arg4 = (wxString *) &arg4_defvalue ;
40042 wxMenuItem *result = 0 ;
40043 void *argp1 = 0 ;
40044 int res1 = 0 ;
40045 int val2 ;
40046 int ecode2 = 0 ;
40047 bool temp3 = false ;
40048 bool temp4 = false ;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 PyObject * obj2 = 0 ;
40052 PyObject * obj3 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 {
40069 arg3 = wxString_in_helper(obj2);
40070 if (arg3 == NULL) SWIG_fail;
40071 temp3 = true;
40072 }
40073 if (obj3) {
40074 {
40075 arg4 = wxString_in_helper(obj3);
40076 if (arg4 == NULL) SWIG_fail;
40077 temp4 = true;
40078 }
40079 }
40080 {
40081 PyThreadState* __tstate = wxPyBeginAllowThreads();
40082 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 resultobj = wxPyMake_wxObject(result, (bool)0);
40088 }
40089 {
40090 if (temp3)
40091 delete arg3;
40092 }
40093 {
40094 if (temp4)
40095 delete arg4;
40096 }
40097 return resultobj;
40098 fail:
40099 {
40100 if (temp3)
40101 delete arg3;
40102 }
40103 {
40104 if (temp4)
40105 delete arg4;
40106 }
40107 return NULL;
40108 }
40109
40110
40111 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40112 PyObject *resultobj = 0;
40113 wxMenu *arg1 = (wxMenu *) 0 ;
40114 int arg2 ;
40115 wxString *arg3 = 0 ;
40116 wxString const &arg4_defvalue = wxPyEmptyString ;
40117 wxString *arg4 = (wxString *) &arg4_defvalue ;
40118 wxMenuItem *result = 0 ;
40119 void *argp1 = 0 ;
40120 int res1 = 0 ;
40121 int val2 ;
40122 int ecode2 = 0 ;
40123 bool temp3 = false ;
40124 bool temp4 = false ;
40125 PyObject * obj0 = 0 ;
40126 PyObject * obj1 = 0 ;
40127 PyObject * obj2 = 0 ;
40128 PyObject * obj3 = 0 ;
40129 char * kwnames[] = {
40130 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40131 };
40132
40133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40135 if (!SWIG_IsOK(res1)) {
40136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40137 }
40138 arg1 = reinterpret_cast< wxMenu * >(argp1);
40139 ecode2 = SWIG_AsVal_int(obj1, &val2);
40140 if (!SWIG_IsOK(ecode2)) {
40141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40142 }
40143 arg2 = static_cast< int >(val2);
40144 {
40145 arg3 = wxString_in_helper(obj2);
40146 if (arg3 == NULL) SWIG_fail;
40147 temp3 = true;
40148 }
40149 if (obj3) {
40150 {
40151 arg4 = wxString_in_helper(obj3);
40152 if (arg4 == NULL) SWIG_fail;
40153 temp4 = true;
40154 }
40155 }
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 {
40163 resultobj = wxPyMake_wxObject(result, (bool)0);
40164 }
40165 {
40166 if (temp3)
40167 delete arg3;
40168 }
40169 {
40170 if (temp4)
40171 delete arg4;
40172 }
40173 return resultobj;
40174 fail:
40175 {
40176 if (temp3)
40177 delete arg3;
40178 }
40179 {
40180 if (temp4)
40181 delete arg4;
40182 }
40183 return NULL;
40184 }
40185
40186
40187 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj = 0;
40189 wxMenu *arg1 = (wxMenu *) 0 ;
40190 int arg2 ;
40191 wxString *arg3 = 0 ;
40192 wxMenu *arg4 = (wxMenu *) 0 ;
40193 wxString const &arg5_defvalue = wxPyEmptyString ;
40194 wxString *arg5 = (wxString *) &arg5_defvalue ;
40195 wxMenuItem *result = 0 ;
40196 void *argp1 = 0 ;
40197 int res1 = 0 ;
40198 int val2 ;
40199 int ecode2 = 0 ;
40200 bool temp3 = false ;
40201 void *argp4 = 0 ;
40202 int res4 = 0 ;
40203 bool temp5 = false ;
40204 PyObject * obj0 = 0 ;
40205 PyObject * obj1 = 0 ;
40206 PyObject * obj2 = 0 ;
40207 PyObject * obj3 = 0 ;
40208 PyObject * obj4 = 0 ;
40209 char * kwnames[] = {
40210 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40211 };
40212
40213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40215 if (!SWIG_IsOK(res1)) {
40216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40217 }
40218 arg1 = reinterpret_cast< wxMenu * >(argp1);
40219 ecode2 = SWIG_AsVal_int(obj1, &val2);
40220 if (!SWIG_IsOK(ecode2)) {
40221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40222 }
40223 arg2 = static_cast< int >(val2);
40224 {
40225 arg3 = wxString_in_helper(obj2);
40226 if (arg3 == NULL) SWIG_fail;
40227 temp3 = true;
40228 }
40229 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40230 if (!SWIG_IsOK(res4)) {
40231 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40232 }
40233 arg4 = reinterpret_cast< wxMenu * >(argp4);
40234 if (obj4) {
40235 {
40236 arg5 = wxString_in_helper(obj4);
40237 if (arg5 == NULL) SWIG_fail;
40238 temp5 = true;
40239 }
40240 }
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = wxPyMake_wxObject(result, (bool)0);
40249 }
40250 {
40251 if (temp3)
40252 delete arg3;
40253 }
40254 {
40255 if (temp5)
40256 delete arg5;
40257 }
40258 return resultobj;
40259 fail:
40260 {
40261 if (temp3)
40262 delete arg3;
40263 }
40264 {
40265 if (temp5)
40266 delete arg5;
40267 }
40268 return NULL;
40269 }
40270
40271
40272 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40273 PyObject *resultobj = 0;
40274 wxMenu *arg1 = (wxMenu *) 0 ;
40275 int arg2 ;
40276 wxMenuItem *result = 0 ;
40277 void *argp1 = 0 ;
40278 int res1 = 0 ;
40279 int val2 ;
40280 int ecode2 = 0 ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char * kwnames[] = {
40284 (char *) "self",(char *) "id", NULL
40285 };
40286
40287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40289 if (!SWIG_IsOK(res1)) {
40290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40291 }
40292 arg1 = reinterpret_cast< wxMenu * >(argp1);
40293 ecode2 = SWIG_AsVal_int(obj1, &val2);
40294 if (!SWIG_IsOK(ecode2)) {
40295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40296 }
40297 arg2 = static_cast< int >(val2);
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 result = (wxMenuItem *)(arg1)->Remove(arg2);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 {
40305 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40306 }
40307 return resultobj;
40308 fail:
40309 return NULL;
40310 }
40311
40312
40313 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40314 PyObject *resultobj = 0;
40315 wxMenu *arg1 = (wxMenu *) 0 ;
40316 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40317 wxMenuItem *result = 0 ;
40318 void *argp1 = 0 ;
40319 int res1 = 0 ;
40320 void *argp2 = 0 ;
40321 int res2 = 0 ;
40322 PyObject * obj0 = 0 ;
40323 PyObject * obj1 = 0 ;
40324 char * kwnames[] = {
40325 (char *) "self",(char *) "item", NULL
40326 };
40327
40328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40330 if (!SWIG_IsOK(res1)) {
40331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40332 }
40333 arg1 = reinterpret_cast< wxMenu * >(argp1);
40334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40335 if (!SWIG_IsOK(res2)) {
40336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40337 }
40338 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 result = (wxMenuItem *)(arg1)->Remove(arg2);
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 {
40346 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40347 }
40348 return resultobj;
40349 fail:
40350 return NULL;
40351 }
40352
40353
40354 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj = 0;
40356 wxMenu *arg1 = (wxMenu *) 0 ;
40357 int arg2 ;
40358 bool result;
40359 void *argp1 = 0 ;
40360 int res1 = 0 ;
40361 int val2 ;
40362 int ecode2 = 0 ;
40363 PyObject * obj0 = 0 ;
40364 PyObject * obj1 = 0 ;
40365 char * kwnames[] = {
40366 (char *) "self",(char *) "id", NULL
40367 };
40368
40369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40371 if (!SWIG_IsOK(res1)) {
40372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40373 }
40374 arg1 = reinterpret_cast< wxMenu * >(argp1);
40375 ecode2 = SWIG_AsVal_int(obj1, &val2);
40376 if (!SWIG_IsOK(ecode2)) {
40377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40378 }
40379 arg2 = static_cast< int >(val2);
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 result = (bool)(arg1)->Delete(arg2);
40383 wxPyEndAllowThreads(__tstate);
40384 if (PyErr_Occurred()) SWIG_fail;
40385 }
40386 {
40387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40388 }
40389 return resultobj;
40390 fail:
40391 return NULL;
40392 }
40393
40394
40395 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40396 PyObject *resultobj = 0;
40397 wxMenu *arg1 = (wxMenu *) 0 ;
40398 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40399 bool result;
40400 void *argp1 = 0 ;
40401 int res1 = 0 ;
40402 void *argp2 = 0 ;
40403 int res2 = 0 ;
40404 PyObject * obj0 = 0 ;
40405 PyObject * obj1 = 0 ;
40406 char * kwnames[] = {
40407 (char *) "self",(char *) "item", NULL
40408 };
40409
40410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40412 if (!SWIG_IsOK(res1)) {
40413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40414 }
40415 arg1 = reinterpret_cast< wxMenu * >(argp1);
40416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40417 if (!SWIG_IsOK(res2)) {
40418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40419 }
40420 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 result = (bool)(arg1)->Delete(arg2);
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 {
40428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40429 }
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40437 PyObject *resultobj = 0;
40438 wxMenu *arg1 = (wxMenu *) 0 ;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 PyObject *swig_obj[1] ;
40442
40443 if (!args) SWIG_fail;
40444 swig_obj[0] = args;
40445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40446 if (!SWIG_IsOK(res1)) {
40447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40448 }
40449 arg1 = reinterpret_cast< wxMenu * >(argp1);
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 wxMenu_Destroy(arg1);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_Py_Void();
40457 return resultobj;
40458 fail:
40459 return NULL;
40460 }
40461
40462
40463 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40464 PyObject *resultobj = 0;
40465 wxMenu *arg1 = (wxMenu *) 0 ;
40466 int arg2 ;
40467 bool result;
40468 void *argp1 = 0 ;
40469 int res1 = 0 ;
40470 int val2 ;
40471 int ecode2 = 0 ;
40472 PyObject * obj0 = 0 ;
40473 PyObject * obj1 = 0 ;
40474 char * kwnames[] = {
40475 (char *) "self",(char *) "id", NULL
40476 };
40477
40478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40480 if (!SWIG_IsOK(res1)) {
40481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40482 }
40483 arg1 = reinterpret_cast< wxMenu * >(argp1);
40484 ecode2 = SWIG_AsVal_int(obj1, &val2);
40485 if (!SWIG_IsOK(ecode2)) {
40486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40487 }
40488 arg2 = static_cast< int >(val2);
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 result = (bool)(arg1)->Destroy(arg2);
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 {
40496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40497 }
40498 return resultobj;
40499 fail:
40500 return NULL;
40501 }
40502
40503
40504 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40505 PyObject *resultobj = 0;
40506 wxMenu *arg1 = (wxMenu *) 0 ;
40507 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40508 bool result;
40509 void *argp1 = 0 ;
40510 int res1 = 0 ;
40511 void *argp2 = 0 ;
40512 int res2 = 0 ;
40513 PyObject * obj0 = 0 ;
40514 PyObject * obj1 = 0 ;
40515 char * kwnames[] = {
40516 (char *) "self",(char *) "item", NULL
40517 };
40518
40519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40521 if (!SWIG_IsOK(res1)) {
40522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40523 }
40524 arg1 = reinterpret_cast< wxMenu * >(argp1);
40525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40526 if (!SWIG_IsOK(res2)) {
40527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40528 }
40529 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 result = (bool)(arg1)->Destroy(arg2);
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 {
40537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40538 }
40539 return resultobj;
40540 fail:
40541 return NULL;
40542 }
40543
40544
40545 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40546 PyObject *resultobj = 0;
40547 wxMenu *arg1 = (wxMenu *) 0 ;
40548 size_t result;
40549 void *argp1 = 0 ;
40550 int res1 = 0 ;
40551 PyObject *swig_obj[1] ;
40552
40553 if (!args) SWIG_fail;
40554 swig_obj[0] = args;
40555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40556 if (!SWIG_IsOK(res1)) {
40557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40558 }
40559 arg1 = reinterpret_cast< wxMenu * >(argp1);
40560 {
40561 PyThreadState* __tstate = wxPyBeginAllowThreads();
40562 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40563 wxPyEndAllowThreads(__tstate);
40564 if (PyErr_Occurred()) SWIG_fail;
40565 }
40566 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40567 return resultobj;
40568 fail:
40569 return NULL;
40570 }
40571
40572
40573 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40574 PyObject *resultobj = 0;
40575 wxMenu *arg1 = (wxMenu *) 0 ;
40576 PyObject *result = 0 ;
40577 void *argp1 = 0 ;
40578 int res1 = 0 ;
40579 PyObject *swig_obj[1] ;
40580
40581 if (!args) SWIG_fail;
40582 swig_obj[0] = args;
40583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40584 if (!SWIG_IsOK(res1)) {
40585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40586 }
40587 arg1 = reinterpret_cast< wxMenu * >(argp1);
40588 {
40589 PyThreadState* __tstate = wxPyBeginAllowThreads();
40590 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40591 wxPyEndAllowThreads(__tstate);
40592 if (PyErr_Occurred()) SWIG_fail;
40593 }
40594 resultobj = result;
40595 return resultobj;
40596 fail:
40597 return NULL;
40598 }
40599
40600
40601 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40602 PyObject *resultobj = 0;
40603 wxMenu *arg1 = (wxMenu *) 0 ;
40604 wxString *arg2 = 0 ;
40605 int result;
40606 void *argp1 = 0 ;
40607 int res1 = 0 ;
40608 bool temp2 = false ;
40609 PyObject * obj0 = 0 ;
40610 PyObject * obj1 = 0 ;
40611 char * kwnames[] = {
40612 (char *) "self",(char *) "item", NULL
40613 };
40614
40615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 {
40622 arg2 = wxString_in_helper(obj1);
40623 if (arg2 == NULL) SWIG_fail;
40624 temp2 = true;
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 resultobj = SWIG_From_int(static_cast< int >(result));
40633 {
40634 if (temp2)
40635 delete arg2;
40636 }
40637 return resultobj;
40638 fail:
40639 {
40640 if (temp2)
40641 delete arg2;
40642 }
40643 return NULL;
40644 }
40645
40646
40647 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40648 PyObject *resultobj = 0;
40649 wxMenu *arg1 = (wxMenu *) 0 ;
40650 int arg2 ;
40651 wxMenuItem *result = 0 ;
40652 void *argp1 = 0 ;
40653 int res1 = 0 ;
40654 int val2 ;
40655 int ecode2 = 0 ;
40656 PyObject * obj0 = 0 ;
40657 PyObject * obj1 = 0 ;
40658 char * kwnames[] = {
40659 (char *) "self",(char *) "id", NULL
40660 };
40661
40662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40664 if (!SWIG_IsOK(res1)) {
40665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40666 }
40667 arg1 = reinterpret_cast< wxMenu * >(argp1);
40668 ecode2 = SWIG_AsVal_int(obj1, &val2);
40669 if (!SWIG_IsOK(ecode2)) {
40670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40671 }
40672 arg2 = static_cast< int >(val2);
40673 {
40674 PyThreadState* __tstate = wxPyBeginAllowThreads();
40675 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40676 wxPyEndAllowThreads(__tstate);
40677 if (PyErr_Occurred()) SWIG_fail;
40678 }
40679 {
40680 resultobj = wxPyMake_wxObject(result, (bool)0);
40681 }
40682 return resultobj;
40683 fail:
40684 return NULL;
40685 }
40686
40687
40688 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40689 PyObject *resultobj = 0;
40690 wxMenu *arg1 = (wxMenu *) 0 ;
40691 size_t arg2 ;
40692 wxMenuItem *result = 0 ;
40693 void *argp1 = 0 ;
40694 int res1 = 0 ;
40695 size_t val2 ;
40696 int ecode2 = 0 ;
40697 PyObject * obj0 = 0 ;
40698 PyObject * obj1 = 0 ;
40699 char * kwnames[] = {
40700 (char *) "self",(char *) "position", NULL
40701 };
40702
40703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40705 if (!SWIG_IsOK(res1)) {
40706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40707 }
40708 arg1 = reinterpret_cast< wxMenu * >(argp1);
40709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40710 if (!SWIG_IsOK(ecode2)) {
40711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40712 }
40713 arg2 = static_cast< size_t >(val2);
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
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_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40730 PyObject *resultobj = 0;
40731 wxMenu *arg1 = (wxMenu *) 0 ;
40732 int arg2 ;
40733 bool arg3 ;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 int val2 ;
40737 int ecode2 = 0 ;
40738 bool val3 ;
40739 int ecode3 = 0 ;
40740 PyObject * obj0 = 0 ;
40741 PyObject * obj1 = 0 ;
40742 PyObject * obj2 = 0 ;
40743 char * kwnames[] = {
40744 (char *) "self",(char *) "id",(char *) "enable", NULL
40745 };
40746
40747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40749 if (!SWIG_IsOK(res1)) {
40750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40751 }
40752 arg1 = reinterpret_cast< wxMenu * >(argp1);
40753 ecode2 = SWIG_AsVal_int(obj1, &val2);
40754 if (!SWIG_IsOK(ecode2)) {
40755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40756 }
40757 arg2 = static_cast< int >(val2);
40758 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40759 if (!SWIG_IsOK(ecode3)) {
40760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40761 }
40762 arg3 = static_cast< bool >(val3);
40763 {
40764 PyThreadState* __tstate = wxPyBeginAllowThreads();
40765 (arg1)->Enable(arg2,arg3);
40766 wxPyEndAllowThreads(__tstate);
40767 if (PyErr_Occurred()) SWIG_fail;
40768 }
40769 resultobj = SWIG_Py_Void();
40770 return resultobj;
40771 fail:
40772 return NULL;
40773 }
40774
40775
40776 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40777 PyObject *resultobj = 0;
40778 wxMenu *arg1 = (wxMenu *) 0 ;
40779 int arg2 ;
40780 bool result;
40781 void *argp1 = 0 ;
40782 int res1 = 0 ;
40783 int val2 ;
40784 int ecode2 = 0 ;
40785 PyObject * obj0 = 0 ;
40786 PyObject * obj1 = 0 ;
40787 char * kwnames[] = {
40788 (char *) "self",(char *) "id", NULL
40789 };
40790
40791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40793 if (!SWIG_IsOK(res1)) {
40794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40795 }
40796 arg1 = reinterpret_cast< wxMenu * >(argp1);
40797 ecode2 = SWIG_AsVal_int(obj1, &val2);
40798 if (!SWIG_IsOK(ecode2)) {
40799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40800 }
40801 arg2 = static_cast< int >(val2);
40802 {
40803 PyThreadState* __tstate = wxPyBeginAllowThreads();
40804 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40805 wxPyEndAllowThreads(__tstate);
40806 if (PyErr_Occurred()) SWIG_fail;
40807 }
40808 {
40809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40810 }
40811 return resultobj;
40812 fail:
40813 return NULL;
40814 }
40815
40816
40817 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40818 PyObject *resultobj = 0;
40819 wxMenu *arg1 = (wxMenu *) 0 ;
40820 int arg2 ;
40821 bool arg3 ;
40822 void *argp1 = 0 ;
40823 int res1 = 0 ;
40824 int val2 ;
40825 int ecode2 = 0 ;
40826 bool val3 ;
40827 int ecode3 = 0 ;
40828 PyObject * obj0 = 0 ;
40829 PyObject * obj1 = 0 ;
40830 PyObject * obj2 = 0 ;
40831 char * kwnames[] = {
40832 (char *) "self",(char *) "id",(char *) "check", NULL
40833 };
40834
40835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40837 if (!SWIG_IsOK(res1)) {
40838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40839 }
40840 arg1 = reinterpret_cast< wxMenu * >(argp1);
40841 ecode2 = SWIG_AsVal_int(obj1, &val2);
40842 if (!SWIG_IsOK(ecode2)) {
40843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40844 }
40845 arg2 = static_cast< int >(val2);
40846 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40847 if (!SWIG_IsOK(ecode3)) {
40848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40849 }
40850 arg3 = static_cast< bool >(val3);
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->Check(arg2,arg3);
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 resultobj = SWIG_Py_Void();
40858 return resultobj;
40859 fail:
40860 return NULL;
40861 }
40862
40863
40864 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40865 PyObject *resultobj = 0;
40866 wxMenu *arg1 = (wxMenu *) 0 ;
40867 int arg2 ;
40868 bool result;
40869 void *argp1 = 0 ;
40870 int res1 = 0 ;
40871 int val2 ;
40872 int ecode2 = 0 ;
40873 PyObject * obj0 = 0 ;
40874 PyObject * obj1 = 0 ;
40875 char * kwnames[] = {
40876 (char *) "self",(char *) "id", NULL
40877 };
40878
40879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40881 if (!SWIG_IsOK(res1)) {
40882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40883 }
40884 arg1 = reinterpret_cast< wxMenu * >(argp1);
40885 ecode2 = SWIG_AsVal_int(obj1, &val2);
40886 if (!SWIG_IsOK(ecode2)) {
40887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40888 }
40889 arg2 = static_cast< int >(val2);
40890 {
40891 PyThreadState* __tstate = wxPyBeginAllowThreads();
40892 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40893 wxPyEndAllowThreads(__tstate);
40894 if (PyErr_Occurred()) SWIG_fail;
40895 }
40896 {
40897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40898 }
40899 return resultobj;
40900 fail:
40901 return NULL;
40902 }
40903
40904
40905 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40906 PyObject *resultobj = 0;
40907 wxMenu *arg1 = (wxMenu *) 0 ;
40908 int arg2 ;
40909 wxString *arg3 = 0 ;
40910 void *argp1 = 0 ;
40911 int res1 = 0 ;
40912 int val2 ;
40913 int ecode2 = 0 ;
40914 bool temp3 = false ;
40915 PyObject * obj0 = 0 ;
40916 PyObject * obj1 = 0 ;
40917 PyObject * obj2 = 0 ;
40918 char * kwnames[] = {
40919 (char *) "self",(char *) "id",(char *) "label", NULL
40920 };
40921
40922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40924 if (!SWIG_IsOK(res1)) {
40925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40926 }
40927 arg1 = reinterpret_cast< wxMenu * >(argp1);
40928 ecode2 = SWIG_AsVal_int(obj1, &val2);
40929 if (!SWIG_IsOK(ecode2)) {
40930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40931 }
40932 arg2 = static_cast< int >(val2);
40933 {
40934 arg3 = wxString_in_helper(obj2);
40935 if (arg3 == NULL) SWIG_fail;
40936 temp3 = true;
40937 }
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40941 wxPyEndAllowThreads(__tstate);
40942 if (PyErr_Occurred()) SWIG_fail;
40943 }
40944 resultobj = SWIG_Py_Void();
40945 {
40946 if (temp3)
40947 delete arg3;
40948 }
40949 return resultobj;
40950 fail:
40951 {
40952 if (temp3)
40953 delete arg3;
40954 }
40955 return NULL;
40956 }
40957
40958
40959 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40960 PyObject *resultobj = 0;
40961 wxMenu *arg1 = (wxMenu *) 0 ;
40962 int arg2 ;
40963 wxString result;
40964 void *argp1 = 0 ;
40965 int res1 = 0 ;
40966 int val2 ;
40967 int ecode2 = 0 ;
40968 PyObject * obj0 = 0 ;
40969 PyObject * obj1 = 0 ;
40970 char * kwnames[] = {
40971 (char *) "self",(char *) "id", NULL
40972 };
40973
40974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40976 if (!SWIG_IsOK(res1)) {
40977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40978 }
40979 arg1 = reinterpret_cast< wxMenu * >(argp1);
40980 ecode2 = SWIG_AsVal_int(obj1, &val2);
40981 if (!SWIG_IsOK(ecode2)) {
40982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40983 }
40984 arg2 = static_cast< int >(val2);
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40988 wxPyEndAllowThreads(__tstate);
40989 if (PyErr_Occurred()) SWIG_fail;
40990 }
40991 {
40992 #if wxUSE_UNICODE
40993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40994 #else
40995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40996 #endif
40997 }
40998 return resultobj;
40999 fail:
41000 return NULL;
41001 }
41002
41003
41004 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41005 PyObject *resultobj = 0;
41006 wxMenu *arg1 = (wxMenu *) 0 ;
41007 int arg2 ;
41008 wxString *arg3 = 0 ;
41009 void *argp1 = 0 ;
41010 int res1 = 0 ;
41011 int val2 ;
41012 int ecode2 = 0 ;
41013 bool temp3 = false ;
41014 PyObject * obj0 = 0 ;
41015 PyObject * obj1 = 0 ;
41016 PyObject * obj2 = 0 ;
41017 char * kwnames[] = {
41018 (char *) "self",(char *) "id",(char *) "helpString", NULL
41019 };
41020
41021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41023 if (!SWIG_IsOK(res1)) {
41024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41025 }
41026 arg1 = reinterpret_cast< wxMenu * >(argp1);
41027 ecode2 = SWIG_AsVal_int(obj1, &val2);
41028 if (!SWIG_IsOK(ecode2)) {
41029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41030 }
41031 arg2 = static_cast< int >(val2);
41032 {
41033 arg3 = wxString_in_helper(obj2);
41034 if (arg3 == NULL) SWIG_fail;
41035 temp3 = true;
41036 }
41037 {
41038 PyThreadState* __tstate = wxPyBeginAllowThreads();
41039 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41040 wxPyEndAllowThreads(__tstate);
41041 if (PyErr_Occurred()) SWIG_fail;
41042 }
41043 resultobj = SWIG_Py_Void();
41044 {
41045 if (temp3)
41046 delete arg3;
41047 }
41048 return resultobj;
41049 fail:
41050 {
41051 if (temp3)
41052 delete arg3;
41053 }
41054 return NULL;
41055 }
41056
41057
41058 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41059 PyObject *resultobj = 0;
41060 wxMenu *arg1 = (wxMenu *) 0 ;
41061 int arg2 ;
41062 wxString result;
41063 void *argp1 = 0 ;
41064 int res1 = 0 ;
41065 int val2 ;
41066 int ecode2 = 0 ;
41067 PyObject * obj0 = 0 ;
41068 PyObject * obj1 = 0 ;
41069 char * kwnames[] = {
41070 (char *) "self",(char *) "id", NULL
41071 };
41072
41073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41075 if (!SWIG_IsOK(res1)) {
41076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41077 }
41078 arg1 = reinterpret_cast< wxMenu * >(argp1);
41079 ecode2 = SWIG_AsVal_int(obj1, &val2);
41080 if (!SWIG_IsOK(ecode2)) {
41081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41082 }
41083 arg2 = static_cast< int >(val2);
41084 {
41085 PyThreadState* __tstate = wxPyBeginAllowThreads();
41086 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 {
41091 #if wxUSE_UNICODE
41092 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41093 #else
41094 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41095 #endif
41096 }
41097 return resultobj;
41098 fail:
41099 return NULL;
41100 }
41101
41102
41103 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41104 PyObject *resultobj = 0;
41105 wxMenu *arg1 = (wxMenu *) 0 ;
41106 wxString *arg2 = 0 ;
41107 void *argp1 = 0 ;
41108 int res1 = 0 ;
41109 bool temp2 = false ;
41110 PyObject * obj0 = 0 ;
41111 PyObject * obj1 = 0 ;
41112 char * kwnames[] = {
41113 (char *) "self",(char *) "title", NULL
41114 };
41115
41116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41118 if (!SWIG_IsOK(res1)) {
41119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41120 }
41121 arg1 = reinterpret_cast< wxMenu * >(argp1);
41122 {
41123 arg2 = wxString_in_helper(obj1);
41124 if (arg2 == NULL) SWIG_fail;
41125 temp2 = true;
41126 }
41127 {
41128 PyThreadState* __tstate = wxPyBeginAllowThreads();
41129 (arg1)->SetTitle((wxString const &)*arg2);
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 resultobj = SWIG_Py_Void();
41134 {
41135 if (temp2)
41136 delete arg2;
41137 }
41138 return resultobj;
41139 fail:
41140 {
41141 if (temp2)
41142 delete arg2;
41143 }
41144 return NULL;
41145 }
41146
41147
41148 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41149 PyObject *resultobj = 0;
41150 wxMenu *arg1 = (wxMenu *) 0 ;
41151 wxString result;
41152 void *argp1 = 0 ;
41153 int res1 = 0 ;
41154 PyObject *swig_obj[1] ;
41155
41156 if (!args) SWIG_fail;
41157 swig_obj[0] = args;
41158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41159 if (!SWIG_IsOK(res1)) {
41160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41161 }
41162 arg1 = reinterpret_cast< wxMenu * >(argp1);
41163 {
41164 PyThreadState* __tstate = wxPyBeginAllowThreads();
41165 result = ((wxMenu const *)arg1)->GetTitle();
41166 wxPyEndAllowThreads(__tstate);
41167 if (PyErr_Occurred()) SWIG_fail;
41168 }
41169 {
41170 #if wxUSE_UNICODE
41171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41172 #else
41173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41174 #endif
41175 }
41176 return resultobj;
41177 fail:
41178 return NULL;
41179 }
41180
41181
41182 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41183 PyObject *resultobj = 0;
41184 wxMenu *arg1 = (wxMenu *) 0 ;
41185 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41186 void *argp1 = 0 ;
41187 int res1 = 0 ;
41188 void *argp2 = 0 ;
41189 int res2 = 0 ;
41190 PyObject * obj0 = 0 ;
41191 PyObject * obj1 = 0 ;
41192 char * kwnames[] = {
41193 (char *) "self",(char *) "handler", NULL
41194 };
41195
41196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41198 if (!SWIG_IsOK(res1)) {
41199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41200 }
41201 arg1 = reinterpret_cast< wxMenu * >(argp1);
41202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41203 if (!SWIG_IsOK(res2)) {
41204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41205 }
41206 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 (arg1)->SetEventHandler(arg2);
41210 wxPyEndAllowThreads(__tstate);
41211 if (PyErr_Occurred()) SWIG_fail;
41212 }
41213 resultobj = SWIG_Py_Void();
41214 return resultobj;
41215 fail:
41216 return NULL;
41217 }
41218
41219
41220 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41221 PyObject *resultobj = 0;
41222 wxMenu *arg1 = (wxMenu *) 0 ;
41223 wxEvtHandler *result = 0 ;
41224 void *argp1 = 0 ;
41225 int res1 = 0 ;
41226 PyObject *swig_obj[1] ;
41227
41228 if (!args) SWIG_fail;
41229 swig_obj[0] = args;
41230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41231 if (!SWIG_IsOK(res1)) {
41232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41233 }
41234 arg1 = reinterpret_cast< wxMenu * >(argp1);
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 {
41242 resultobj = wxPyMake_wxObject(result, 0);
41243 }
41244 return resultobj;
41245 fail:
41246 return NULL;
41247 }
41248
41249
41250 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41251 PyObject *resultobj = 0;
41252 wxMenu *arg1 = (wxMenu *) 0 ;
41253 wxWindow *arg2 = (wxWindow *) 0 ;
41254 void *argp1 = 0 ;
41255 int res1 = 0 ;
41256 void *argp2 = 0 ;
41257 int res2 = 0 ;
41258 PyObject * obj0 = 0 ;
41259 PyObject * obj1 = 0 ;
41260 char * kwnames[] = {
41261 (char *) "self",(char *) "win", NULL
41262 };
41263
41264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41266 if (!SWIG_IsOK(res1)) {
41267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41268 }
41269 arg1 = reinterpret_cast< wxMenu * >(argp1);
41270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41271 if (!SWIG_IsOK(res2)) {
41272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41273 }
41274 arg2 = reinterpret_cast< wxWindow * >(argp2);
41275 {
41276 PyThreadState* __tstate = wxPyBeginAllowThreads();
41277 (arg1)->SetInvokingWindow(arg2);
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 resultobj = SWIG_Py_Void();
41282 return resultobj;
41283 fail:
41284 return NULL;
41285 }
41286
41287
41288 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41289 PyObject *resultobj = 0;
41290 wxMenu *arg1 = (wxMenu *) 0 ;
41291 wxWindow *result = 0 ;
41292 void *argp1 = 0 ;
41293 int res1 = 0 ;
41294 PyObject *swig_obj[1] ;
41295
41296 if (!args) SWIG_fail;
41297 swig_obj[0] = args;
41298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41299 if (!SWIG_IsOK(res1)) {
41300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41301 }
41302 arg1 = reinterpret_cast< wxMenu * >(argp1);
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41306 wxPyEndAllowThreads(__tstate);
41307 if (PyErr_Occurred()) SWIG_fail;
41308 }
41309 {
41310 resultobj = wxPyMake_wxObject(result, 0);
41311 }
41312 return resultobj;
41313 fail:
41314 return NULL;
41315 }
41316
41317
41318 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41319 PyObject *resultobj = 0;
41320 wxMenu *arg1 = (wxMenu *) 0 ;
41321 long result;
41322 void *argp1 = 0 ;
41323 int res1 = 0 ;
41324 PyObject *swig_obj[1] ;
41325
41326 if (!args) SWIG_fail;
41327 swig_obj[0] = args;
41328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41329 if (!SWIG_IsOK(res1)) {
41330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41331 }
41332 arg1 = reinterpret_cast< wxMenu * >(argp1);
41333 {
41334 PyThreadState* __tstate = wxPyBeginAllowThreads();
41335 result = (long)((wxMenu const *)arg1)->GetStyle();
41336 wxPyEndAllowThreads(__tstate);
41337 if (PyErr_Occurred()) SWIG_fail;
41338 }
41339 resultobj = SWIG_From_long(static_cast< long >(result));
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41347 PyObject *resultobj = 0;
41348 wxMenu *arg1 = (wxMenu *) 0 ;
41349 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41350 void *argp1 = 0 ;
41351 int res1 = 0 ;
41352 void *argp2 = 0 ;
41353 int res2 = 0 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 char * kwnames[] = {
41357 (char *) "self",(char *) "source", NULL
41358 };
41359
41360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41362 if (!SWIG_IsOK(res1)) {
41363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41364 }
41365 arg1 = reinterpret_cast< wxMenu * >(argp1);
41366 if (obj1) {
41367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41368 if (!SWIG_IsOK(res2)) {
41369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41370 }
41371 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41372 }
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 (arg1)->UpdateUI(arg2);
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 resultobj = SWIG_Py_Void();
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41387 PyObject *resultobj = 0;
41388 wxMenu *arg1 = (wxMenu *) 0 ;
41389 wxMenuBar *result = 0 ;
41390 void *argp1 = 0 ;
41391 int res1 = 0 ;
41392 PyObject *swig_obj[1] ;
41393
41394 if (!args) SWIG_fail;
41395 swig_obj[0] = args;
41396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41397 if (!SWIG_IsOK(res1)) {
41398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41399 }
41400 arg1 = reinterpret_cast< wxMenu * >(argp1);
41401 {
41402 PyThreadState* __tstate = wxPyBeginAllowThreads();
41403 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 {
41408 resultobj = wxPyMake_wxObject(result, (bool)0);
41409 }
41410 return resultobj;
41411 fail:
41412 return NULL;
41413 }
41414
41415
41416 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41417 PyObject *resultobj = 0;
41418 wxMenu *arg1 = (wxMenu *) 0 ;
41419 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 void *argp2 = 0 ;
41423 int res2 = 0 ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 char * kwnames[] = {
41427 (char *) "self",(char *) "menubar", NULL
41428 };
41429
41430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41434 }
41435 arg1 = reinterpret_cast< wxMenu * >(argp1);
41436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41437 if (!SWIG_IsOK(res2)) {
41438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41439 }
41440 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 (arg1)->Attach(arg2);
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 resultobj = SWIG_Py_Void();
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41455 PyObject *resultobj = 0;
41456 wxMenu *arg1 = (wxMenu *) 0 ;
41457 void *argp1 = 0 ;
41458 int res1 = 0 ;
41459 PyObject *swig_obj[1] ;
41460
41461 if (!args) SWIG_fail;
41462 swig_obj[0] = args;
41463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41464 if (!SWIG_IsOK(res1)) {
41465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41466 }
41467 arg1 = reinterpret_cast< wxMenu * >(argp1);
41468 {
41469 PyThreadState* __tstate = wxPyBeginAllowThreads();
41470 (arg1)->Detach();
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 resultobj = SWIG_Py_Void();
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41482 PyObject *resultobj = 0;
41483 wxMenu *arg1 = (wxMenu *) 0 ;
41484 bool result;
41485 void *argp1 = 0 ;
41486 int res1 = 0 ;
41487 PyObject *swig_obj[1] ;
41488
41489 if (!args) SWIG_fail;
41490 swig_obj[0] = args;
41491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41492 if (!SWIG_IsOK(res1)) {
41493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41494 }
41495 arg1 = reinterpret_cast< wxMenu * >(argp1);
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (bool)((wxMenu const *)arg1)->IsAttached();
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_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj = 0;
41513 wxMenu *arg1 = (wxMenu *) 0 ;
41514 wxMenu *arg2 = (wxMenu *) 0 ;
41515 void *argp1 = 0 ;
41516 int res1 = 0 ;
41517 void *argp2 = 0 ;
41518 int res2 = 0 ;
41519 PyObject * obj0 = 0 ;
41520 PyObject * obj1 = 0 ;
41521 char * kwnames[] = {
41522 (char *) "self",(char *) "parent", NULL
41523 };
41524
41525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41527 if (!SWIG_IsOK(res1)) {
41528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41529 }
41530 arg1 = reinterpret_cast< wxMenu * >(argp1);
41531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41532 if (!SWIG_IsOK(res2)) {
41533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41534 }
41535 arg2 = reinterpret_cast< wxMenu * >(argp2);
41536 {
41537 PyThreadState* __tstate = wxPyBeginAllowThreads();
41538 (arg1)->SetParent(arg2);
41539 wxPyEndAllowThreads(__tstate);
41540 if (PyErr_Occurred()) SWIG_fail;
41541 }
41542 resultobj = SWIG_Py_Void();
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41550 PyObject *resultobj = 0;
41551 wxMenu *arg1 = (wxMenu *) 0 ;
41552 wxMenu *result = 0 ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 PyObject *swig_obj[1] ;
41556
41557 if (!args) SWIG_fail;
41558 swig_obj[0] = args;
41559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41560 if (!SWIG_IsOK(res1)) {
41561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41562 }
41563 arg1 = reinterpret_cast< wxMenu * >(argp1);
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41567 wxPyEndAllowThreads(__tstate);
41568 if (PyErr_Occurred()) SWIG_fail;
41569 }
41570 {
41571 resultobj = wxPyMake_wxObject(result, 0);
41572 }
41573 return resultobj;
41574 fail:
41575 return NULL;
41576 }
41577
41578
41579 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41580 PyObject *obj;
41581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41582 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41583 return SWIG_Py_Void();
41584 }
41585
41586 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41587 return SWIG_Python_InitShadowInstance(args);
41588 }
41589
41590 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41591 PyObject *resultobj = 0;
41592 long arg1 = (long) 0 ;
41593 wxMenuBar *result = 0 ;
41594 long val1 ;
41595 int ecode1 = 0 ;
41596 PyObject * obj0 = 0 ;
41597 char * kwnames[] = {
41598 (char *) "style", NULL
41599 };
41600
41601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41602 if (obj0) {
41603 ecode1 = SWIG_AsVal_long(obj0, &val1);
41604 if (!SWIG_IsOK(ecode1)) {
41605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41606 }
41607 arg1 = static_cast< long >(val1);
41608 }
41609 {
41610 if (!wxPyCheckForApp()) SWIG_fail;
41611 PyThreadState* __tstate = wxPyBeginAllowThreads();
41612 result = (wxMenuBar *)new wxMenuBar(arg1);
41613 wxPyEndAllowThreads(__tstate);
41614 if (PyErr_Occurred()) SWIG_fail;
41615 }
41616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41617 return resultobj;
41618 fail:
41619 return NULL;
41620 }
41621
41622
41623 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41624 PyObject *resultobj = 0;
41625 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41626 wxMenu *arg2 = (wxMenu *) 0 ;
41627 wxString *arg3 = 0 ;
41628 bool result;
41629 void *argp1 = 0 ;
41630 int res1 = 0 ;
41631 void *argp2 = 0 ;
41632 int res2 = 0 ;
41633 bool temp3 = false ;
41634 PyObject * obj0 = 0 ;
41635 PyObject * obj1 = 0 ;
41636 PyObject * obj2 = 0 ;
41637 char * kwnames[] = {
41638 (char *) "self",(char *) "menu",(char *) "title", NULL
41639 };
41640
41641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41643 if (!SWIG_IsOK(res1)) {
41644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41645 }
41646 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41648 if (!SWIG_IsOK(res2)) {
41649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41650 }
41651 arg2 = reinterpret_cast< wxMenu * >(argp2);
41652 {
41653 arg3 = wxString_in_helper(obj2);
41654 if (arg3 == NULL) SWIG_fail;
41655 temp3 = true;
41656 }
41657 {
41658 PyThreadState* __tstate = wxPyBeginAllowThreads();
41659 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41660 wxPyEndAllowThreads(__tstate);
41661 if (PyErr_Occurred()) SWIG_fail;
41662 }
41663 {
41664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41665 }
41666 {
41667 if (temp3)
41668 delete arg3;
41669 }
41670 return resultobj;
41671 fail:
41672 {
41673 if (temp3)
41674 delete arg3;
41675 }
41676 return NULL;
41677 }
41678
41679
41680 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41681 PyObject *resultobj = 0;
41682 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41683 size_t arg2 ;
41684 wxMenu *arg3 = (wxMenu *) 0 ;
41685 wxString *arg4 = 0 ;
41686 bool result;
41687 void *argp1 = 0 ;
41688 int res1 = 0 ;
41689 size_t val2 ;
41690 int ecode2 = 0 ;
41691 void *argp3 = 0 ;
41692 int res3 = 0 ;
41693 bool temp4 = false ;
41694 PyObject * obj0 = 0 ;
41695 PyObject * obj1 = 0 ;
41696 PyObject * obj2 = 0 ;
41697 PyObject * obj3 = 0 ;
41698 char * kwnames[] = {
41699 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41700 };
41701
41702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41704 if (!SWIG_IsOK(res1)) {
41705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41706 }
41707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41708 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41709 if (!SWIG_IsOK(ecode2)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41711 }
41712 arg2 = static_cast< size_t >(val2);
41713 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41714 if (!SWIG_IsOK(res3)) {
41715 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41716 }
41717 arg3 = reinterpret_cast< wxMenu * >(argp3);
41718 {
41719 arg4 = wxString_in_helper(obj3);
41720 if (arg4 == NULL) SWIG_fail;
41721 temp4 = true;
41722 }
41723 {
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 {
41730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41731 }
41732 {
41733 if (temp4)
41734 delete arg4;
41735 }
41736 return resultobj;
41737 fail:
41738 {
41739 if (temp4)
41740 delete arg4;
41741 }
41742 return NULL;
41743 }
41744
41745
41746 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41747 PyObject *resultobj = 0;
41748 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41749 size_t result;
41750 void *argp1 = 0 ;
41751 int res1 = 0 ;
41752 PyObject *swig_obj[1] ;
41753
41754 if (!args) SWIG_fail;
41755 swig_obj[0] = args;
41756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41757 if (!SWIG_IsOK(res1)) {
41758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41759 }
41760 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41768 return resultobj;
41769 fail:
41770 return NULL;
41771 }
41772
41773
41774 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41775 PyObject *resultobj = 0;
41776 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41777 size_t arg2 ;
41778 wxMenu *result = 0 ;
41779 void *argp1 = 0 ;
41780 int res1 = 0 ;
41781 size_t val2 ;
41782 int ecode2 = 0 ;
41783 PyObject * obj0 = 0 ;
41784 PyObject * obj1 = 0 ;
41785 char * kwnames[] = {
41786 (char *) "self",(char *) "pos", NULL
41787 };
41788
41789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41791 if (!SWIG_IsOK(res1)) {
41792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41793 }
41794 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41795 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41796 if (!SWIG_IsOK(ecode2)) {
41797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41798 }
41799 arg2 = static_cast< size_t >(val2);
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41803 wxPyEndAllowThreads(__tstate);
41804 if (PyErr_Occurred()) SWIG_fail;
41805 }
41806 {
41807 resultobj = wxPyMake_wxObject(result, 0);
41808 }
41809 return resultobj;
41810 fail:
41811 return NULL;
41812 }
41813
41814
41815 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41816 PyObject *resultobj = 0;
41817 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41818 size_t arg2 ;
41819 wxMenu *arg3 = (wxMenu *) 0 ;
41820 wxString *arg4 = 0 ;
41821 wxMenu *result = 0 ;
41822 void *argp1 = 0 ;
41823 int res1 = 0 ;
41824 size_t val2 ;
41825 int ecode2 = 0 ;
41826 void *argp3 = 0 ;
41827 int res3 = 0 ;
41828 bool temp4 = false ;
41829 PyObject * obj0 = 0 ;
41830 PyObject * obj1 = 0 ;
41831 PyObject * obj2 = 0 ;
41832 PyObject * obj3 = 0 ;
41833 char * kwnames[] = {
41834 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41835 };
41836
41837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41839 if (!SWIG_IsOK(res1)) {
41840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41841 }
41842 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41843 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41844 if (!SWIG_IsOK(ecode2)) {
41845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41846 }
41847 arg2 = static_cast< size_t >(val2);
41848 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41849 if (!SWIG_IsOK(res3)) {
41850 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41851 }
41852 arg3 = reinterpret_cast< wxMenu * >(argp3);
41853 {
41854 arg4 = wxString_in_helper(obj3);
41855 if (arg4 == NULL) SWIG_fail;
41856 temp4 = true;
41857 }
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41861 wxPyEndAllowThreads(__tstate);
41862 if (PyErr_Occurred()) SWIG_fail;
41863 }
41864 {
41865 resultobj = wxPyMake_wxObject(result, 0);
41866 }
41867 {
41868 if (temp4)
41869 delete arg4;
41870 }
41871 return resultobj;
41872 fail:
41873 {
41874 if (temp4)
41875 delete arg4;
41876 }
41877 return NULL;
41878 }
41879
41880
41881 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41882 PyObject *resultobj = 0;
41883 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41884 size_t arg2 ;
41885 wxMenu *result = 0 ;
41886 void *argp1 = 0 ;
41887 int res1 = 0 ;
41888 size_t val2 ;
41889 int ecode2 = 0 ;
41890 PyObject * obj0 = 0 ;
41891 PyObject * obj1 = 0 ;
41892 char * kwnames[] = {
41893 (char *) "self",(char *) "pos", NULL
41894 };
41895
41896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41898 if (!SWIG_IsOK(res1)) {
41899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41900 }
41901 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41902 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41903 if (!SWIG_IsOK(ecode2)) {
41904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41905 }
41906 arg2 = static_cast< size_t >(val2);
41907 {
41908 PyThreadState* __tstate = wxPyBeginAllowThreads();
41909 result = (wxMenu *)(arg1)->Remove(arg2);
41910 wxPyEndAllowThreads(__tstate);
41911 if (PyErr_Occurred()) SWIG_fail;
41912 }
41913 {
41914 resultobj = wxPyMake_wxObject(result, 0);
41915 }
41916 return resultobj;
41917 fail:
41918 return NULL;
41919 }
41920
41921
41922 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41923 PyObject *resultobj = 0;
41924 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41925 size_t arg2 ;
41926 bool arg3 ;
41927 void *argp1 = 0 ;
41928 int res1 = 0 ;
41929 size_t val2 ;
41930 int ecode2 = 0 ;
41931 bool val3 ;
41932 int ecode3 = 0 ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 PyObject * obj2 = 0 ;
41936 char * kwnames[] = {
41937 (char *) "self",(char *) "pos",(char *) "enable", NULL
41938 };
41939
41940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41942 if (!SWIG_IsOK(res1)) {
41943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41944 }
41945 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41946 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41947 if (!SWIG_IsOK(ecode2)) {
41948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41949 }
41950 arg2 = static_cast< size_t >(val2);
41951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41952 if (!SWIG_IsOK(ecode3)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41954 }
41955 arg3 = static_cast< bool >(val3);
41956 {
41957 PyThreadState* __tstate = wxPyBeginAllowThreads();
41958 (arg1)->EnableTop(arg2,arg3);
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 resultobj = SWIG_Py_Void();
41963 return resultobj;
41964 fail:
41965 return NULL;
41966 }
41967
41968
41969 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj = 0;
41971 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41972 size_t arg2 ;
41973 bool result;
41974 void *argp1 = 0 ;
41975 int res1 = 0 ;
41976 size_t val2 ;
41977 int ecode2 = 0 ;
41978 PyObject * obj0 = 0 ;
41979 PyObject * obj1 = 0 ;
41980 char * kwnames[] = {
41981 (char *) "self",(char *) "pos", NULL
41982 };
41983
41984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41986 if (!SWIG_IsOK(res1)) {
41987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41988 }
41989 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41990 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41991 if (!SWIG_IsOK(ecode2)) {
41992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41993 }
41994 arg2 = static_cast< size_t >(val2);
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 {
42002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42003 }
42004 return resultobj;
42005 fail:
42006 return NULL;
42007 }
42008
42009
42010 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42011 PyObject *resultobj = 0;
42012 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42013 size_t arg2 ;
42014 wxString *arg3 = 0 ;
42015 void *argp1 = 0 ;
42016 int res1 = 0 ;
42017 size_t val2 ;
42018 int ecode2 = 0 ;
42019 bool temp3 = false ;
42020 PyObject * obj0 = 0 ;
42021 PyObject * obj1 = 0 ;
42022 PyObject * obj2 = 0 ;
42023 char * kwnames[] = {
42024 (char *) "self",(char *) "pos",(char *) "label", NULL
42025 };
42026
42027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42029 if (!SWIG_IsOK(res1)) {
42030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42031 }
42032 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42033 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42034 if (!SWIG_IsOK(ecode2)) {
42035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42036 }
42037 arg2 = static_cast< size_t >(val2);
42038 {
42039 arg3 = wxString_in_helper(obj2);
42040 if (arg3 == NULL) SWIG_fail;
42041 temp3 = true;
42042 }
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42046 wxPyEndAllowThreads(__tstate);
42047 if (PyErr_Occurred()) SWIG_fail;
42048 }
42049 resultobj = SWIG_Py_Void();
42050 {
42051 if (temp3)
42052 delete arg3;
42053 }
42054 return resultobj;
42055 fail:
42056 {
42057 if (temp3)
42058 delete arg3;
42059 }
42060 return NULL;
42061 }
42062
42063
42064 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42065 PyObject *resultobj = 0;
42066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42067 size_t arg2 ;
42068 wxString result;
42069 void *argp1 = 0 ;
42070 int res1 = 0 ;
42071 size_t val2 ;
42072 int ecode2 = 0 ;
42073 PyObject * obj0 = 0 ;
42074 PyObject * obj1 = 0 ;
42075 char * kwnames[] = {
42076 (char *) "self",(char *) "pos", NULL
42077 };
42078
42079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42081 if (!SWIG_IsOK(res1)) {
42082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42083 }
42084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42085 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42086 if (!SWIG_IsOK(ecode2)) {
42087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42088 }
42089 arg2 = static_cast< size_t >(val2);
42090 {
42091 PyThreadState* __tstate = wxPyBeginAllowThreads();
42092 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42093 wxPyEndAllowThreads(__tstate);
42094 if (PyErr_Occurred()) SWIG_fail;
42095 }
42096 {
42097 #if wxUSE_UNICODE
42098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42099 #else
42100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42101 #endif
42102 }
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42110 PyObject *resultobj = 0;
42111 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42112 wxString *arg2 = 0 ;
42113 wxString *arg3 = 0 ;
42114 int result;
42115 void *argp1 = 0 ;
42116 int res1 = 0 ;
42117 bool temp2 = false ;
42118 bool temp3 = false ;
42119 PyObject * obj0 = 0 ;
42120 PyObject * obj1 = 0 ;
42121 PyObject * obj2 = 0 ;
42122 char * kwnames[] = {
42123 (char *) "self",(char *) "menu",(char *) "item", NULL
42124 };
42125
42126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42128 if (!SWIG_IsOK(res1)) {
42129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42130 }
42131 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42132 {
42133 arg2 = wxString_in_helper(obj1);
42134 if (arg2 == NULL) SWIG_fail;
42135 temp2 = true;
42136 }
42137 {
42138 arg3 = wxString_in_helper(obj2);
42139 if (arg3 == NULL) SWIG_fail;
42140 temp3 = true;
42141 }
42142 {
42143 PyThreadState* __tstate = wxPyBeginAllowThreads();
42144 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 resultobj = SWIG_From_int(static_cast< int >(result));
42149 {
42150 if (temp2)
42151 delete arg2;
42152 }
42153 {
42154 if (temp3)
42155 delete arg3;
42156 }
42157 return resultobj;
42158 fail:
42159 {
42160 if (temp2)
42161 delete arg2;
42162 }
42163 {
42164 if (temp3)
42165 delete arg3;
42166 }
42167 return NULL;
42168 }
42169
42170
42171 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42172 PyObject *resultobj = 0;
42173 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42174 int arg2 ;
42175 wxMenuItem *result = 0 ;
42176 void *argp1 = 0 ;
42177 int res1 = 0 ;
42178 int val2 ;
42179 int ecode2 = 0 ;
42180 PyObject * obj0 = 0 ;
42181 PyObject * obj1 = 0 ;
42182 char * kwnames[] = {
42183 (char *) "self",(char *) "id", NULL
42184 };
42185
42186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42192 ecode2 = SWIG_AsVal_int(obj1, &val2);
42193 if (!SWIG_IsOK(ecode2)) {
42194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42195 }
42196 arg2 = static_cast< int >(val2);
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 {
42204 resultobj = wxPyMake_wxObject(result, (bool)0);
42205 }
42206 return resultobj;
42207 fail:
42208 return NULL;
42209 }
42210
42211
42212 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj = 0;
42214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42215 wxString *arg2 = 0 ;
42216 int result;
42217 void *argp1 = 0 ;
42218 int res1 = 0 ;
42219 bool temp2 = false ;
42220 PyObject * obj0 = 0 ;
42221 PyObject * obj1 = 0 ;
42222 char * kwnames[] = {
42223 (char *) "self",(char *) "title", NULL
42224 };
42225
42226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42228 if (!SWIG_IsOK(res1)) {
42229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42230 }
42231 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42232 {
42233 arg2 = wxString_in_helper(obj1);
42234 if (arg2 == NULL) SWIG_fail;
42235 temp2 = true;
42236 }
42237 {
42238 PyThreadState* __tstate = wxPyBeginAllowThreads();
42239 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42240 wxPyEndAllowThreads(__tstate);
42241 if (PyErr_Occurred()) SWIG_fail;
42242 }
42243 resultobj = SWIG_From_int(static_cast< int >(result));
42244 {
42245 if (temp2)
42246 delete arg2;
42247 }
42248 return resultobj;
42249 fail:
42250 {
42251 if (temp2)
42252 delete arg2;
42253 }
42254 return NULL;
42255 }
42256
42257
42258 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42259 PyObject *resultobj = 0;
42260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42261 int arg2 ;
42262 bool arg3 ;
42263 void *argp1 = 0 ;
42264 int res1 = 0 ;
42265 int val2 ;
42266 int ecode2 = 0 ;
42267 bool val3 ;
42268 int ecode3 = 0 ;
42269 PyObject * obj0 = 0 ;
42270 PyObject * obj1 = 0 ;
42271 PyObject * obj2 = 0 ;
42272 char * kwnames[] = {
42273 (char *) "self",(char *) "id",(char *) "enable", NULL
42274 };
42275
42276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42278 if (!SWIG_IsOK(res1)) {
42279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42280 }
42281 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42282 ecode2 = SWIG_AsVal_int(obj1, &val2);
42283 if (!SWIG_IsOK(ecode2)) {
42284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42285 }
42286 arg2 = static_cast< int >(val2);
42287 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42288 if (!SWIG_IsOK(ecode3)) {
42289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42290 }
42291 arg3 = static_cast< bool >(val3);
42292 {
42293 PyThreadState* __tstate = wxPyBeginAllowThreads();
42294 (arg1)->Enable(arg2,arg3);
42295 wxPyEndAllowThreads(__tstate);
42296 if (PyErr_Occurred()) SWIG_fail;
42297 }
42298 resultobj = SWIG_Py_Void();
42299 return resultobj;
42300 fail:
42301 return NULL;
42302 }
42303
42304
42305 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42306 PyObject *resultobj = 0;
42307 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42308 int arg2 ;
42309 bool arg3 ;
42310 void *argp1 = 0 ;
42311 int res1 = 0 ;
42312 int val2 ;
42313 int ecode2 = 0 ;
42314 bool val3 ;
42315 int ecode3 = 0 ;
42316 PyObject * obj0 = 0 ;
42317 PyObject * obj1 = 0 ;
42318 PyObject * obj2 = 0 ;
42319 char * kwnames[] = {
42320 (char *) "self",(char *) "id",(char *) "check", NULL
42321 };
42322
42323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42325 if (!SWIG_IsOK(res1)) {
42326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42327 }
42328 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42329 ecode2 = SWIG_AsVal_int(obj1, &val2);
42330 if (!SWIG_IsOK(ecode2)) {
42331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42332 }
42333 arg2 = static_cast< int >(val2);
42334 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42335 if (!SWIG_IsOK(ecode3)) {
42336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42337 }
42338 arg3 = static_cast< bool >(val3);
42339 {
42340 PyThreadState* __tstate = wxPyBeginAllowThreads();
42341 (arg1)->Check(arg2,arg3);
42342 wxPyEndAllowThreads(__tstate);
42343 if (PyErr_Occurred()) SWIG_fail;
42344 }
42345 resultobj = SWIG_Py_Void();
42346 return resultobj;
42347 fail:
42348 return NULL;
42349 }
42350
42351
42352 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42353 PyObject *resultobj = 0;
42354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42355 int arg2 ;
42356 bool result;
42357 void *argp1 = 0 ;
42358 int res1 = 0 ;
42359 int val2 ;
42360 int ecode2 = 0 ;
42361 PyObject * obj0 = 0 ;
42362 PyObject * obj1 = 0 ;
42363 char * kwnames[] = {
42364 (char *) "self",(char *) "id", NULL
42365 };
42366
42367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42369 if (!SWIG_IsOK(res1)) {
42370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42371 }
42372 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42373 ecode2 = SWIG_AsVal_int(obj1, &val2);
42374 if (!SWIG_IsOK(ecode2)) {
42375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42376 }
42377 arg2 = static_cast< int >(val2);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 {
42385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42386 }
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42394 PyObject *resultobj = 0;
42395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42396 int arg2 ;
42397 bool result;
42398 void *argp1 = 0 ;
42399 int res1 = 0 ;
42400 int val2 ;
42401 int ecode2 = 0 ;
42402 PyObject * obj0 = 0 ;
42403 PyObject * obj1 = 0 ;
42404 char * kwnames[] = {
42405 (char *) "self",(char *) "id", NULL
42406 };
42407
42408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42410 if (!SWIG_IsOK(res1)) {
42411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42412 }
42413 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42414 ecode2 = SWIG_AsVal_int(obj1, &val2);
42415 if (!SWIG_IsOK(ecode2)) {
42416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42417 }
42418 arg2 = static_cast< int >(val2);
42419 {
42420 PyThreadState* __tstate = wxPyBeginAllowThreads();
42421 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42422 wxPyEndAllowThreads(__tstate);
42423 if (PyErr_Occurred()) SWIG_fail;
42424 }
42425 {
42426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42427 }
42428 return resultobj;
42429 fail:
42430 return NULL;
42431 }
42432
42433
42434 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42435 PyObject *resultobj = 0;
42436 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42437 int arg2 ;
42438 wxString *arg3 = 0 ;
42439 void *argp1 = 0 ;
42440 int res1 = 0 ;
42441 int val2 ;
42442 int ecode2 = 0 ;
42443 bool temp3 = false ;
42444 PyObject * obj0 = 0 ;
42445 PyObject * obj1 = 0 ;
42446 PyObject * obj2 = 0 ;
42447 char * kwnames[] = {
42448 (char *) "self",(char *) "id",(char *) "label", NULL
42449 };
42450
42451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42453 if (!SWIG_IsOK(res1)) {
42454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42455 }
42456 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42457 ecode2 = SWIG_AsVal_int(obj1, &val2);
42458 if (!SWIG_IsOK(ecode2)) {
42459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42460 }
42461 arg2 = static_cast< int >(val2);
42462 {
42463 arg3 = wxString_in_helper(obj2);
42464 if (arg3 == NULL) SWIG_fail;
42465 temp3 = true;
42466 }
42467 {
42468 PyThreadState* __tstate = wxPyBeginAllowThreads();
42469 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 resultobj = SWIG_Py_Void();
42474 {
42475 if (temp3)
42476 delete arg3;
42477 }
42478 return resultobj;
42479 fail:
42480 {
42481 if (temp3)
42482 delete arg3;
42483 }
42484 return NULL;
42485 }
42486
42487
42488 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42489 PyObject *resultobj = 0;
42490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42491 int arg2 ;
42492 wxString result;
42493 void *argp1 = 0 ;
42494 int res1 = 0 ;
42495 int val2 ;
42496 int ecode2 = 0 ;
42497 PyObject * obj0 = 0 ;
42498 PyObject * obj1 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "id", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42509 ecode2 = SWIG_AsVal_int(obj1, &val2);
42510 if (!SWIG_IsOK(ecode2)) {
42511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42512 }
42513 arg2 = static_cast< int >(val2);
42514 {
42515 PyThreadState* __tstate = wxPyBeginAllowThreads();
42516 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42517 wxPyEndAllowThreads(__tstate);
42518 if (PyErr_Occurred()) SWIG_fail;
42519 }
42520 {
42521 #if wxUSE_UNICODE
42522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42523 #else
42524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42525 #endif
42526 }
42527 return resultobj;
42528 fail:
42529 return NULL;
42530 }
42531
42532
42533 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42534 PyObject *resultobj = 0;
42535 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42536 int arg2 ;
42537 wxString *arg3 = 0 ;
42538 void *argp1 = 0 ;
42539 int res1 = 0 ;
42540 int val2 ;
42541 int ecode2 = 0 ;
42542 bool temp3 = false ;
42543 PyObject * obj0 = 0 ;
42544 PyObject * obj1 = 0 ;
42545 PyObject * obj2 = 0 ;
42546 char * kwnames[] = {
42547 (char *) "self",(char *) "id",(char *) "helpString", NULL
42548 };
42549
42550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42552 if (!SWIG_IsOK(res1)) {
42553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42554 }
42555 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42556 ecode2 = SWIG_AsVal_int(obj1, &val2);
42557 if (!SWIG_IsOK(ecode2)) {
42558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42559 }
42560 arg2 = static_cast< int >(val2);
42561 {
42562 arg3 = wxString_in_helper(obj2);
42563 if (arg3 == NULL) SWIG_fail;
42564 temp3 = true;
42565 }
42566 {
42567 PyThreadState* __tstate = wxPyBeginAllowThreads();
42568 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42569 wxPyEndAllowThreads(__tstate);
42570 if (PyErr_Occurred()) SWIG_fail;
42571 }
42572 resultobj = SWIG_Py_Void();
42573 {
42574 if (temp3)
42575 delete arg3;
42576 }
42577 return resultobj;
42578 fail:
42579 {
42580 if (temp3)
42581 delete arg3;
42582 }
42583 return NULL;
42584 }
42585
42586
42587 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42588 PyObject *resultobj = 0;
42589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42590 int arg2 ;
42591 wxString result;
42592 void *argp1 = 0 ;
42593 int res1 = 0 ;
42594 int val2 ;
42595 int ecode2 = 0 ;
42596 PyObject * obj0 = 0 ;
42597 PyObject * obj1 = 0 ;
42598 char * kwnames[] = {
42599 (char *) "self",(char *) "id", NULL
42600 };
42601
42602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42604 if (!SWIG_IsOK(res1)) {
42605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42606 }
42607 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42608 ecode2 = SWIG_AsVal_int(obj1, &val2);
42609 if (!SWIG_IsOK(ecode2)) {
42610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42611 }
42612 arg2 = static_cast< int >(val2);
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42616 wxPyEndAllowThreads(__tstate);
42617 if (PyErr_Occurred()) SWIG_fail;
42618 }
42619 {
42620 #if wxUSE_UNICODE
42621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42622 #else
42623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42624 #endif
42625 }
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42633 PyObject *resultobj = 0;
42634 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42635 wxFrame *result = 0 ;
42636 void *argp1 = 0 ;
42637 int res1 = 0 ;
42638 PyObject *swig_obj[1] ;
42639
42640 if (!args) SWIG_fail;
42641 swig_obj[0] = args;
42642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42643 if (!SWIG_IsOK(res1)) {
42644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42645 }
42646 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42647 {
42648 PyThreadState* __tstate = wxPyBeginAllowThreads();
42649 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42650 wxPyEndAllowThreads(__tstate);
42651 if (PyErr_Occurred()) SWIG_fail;
42652 }
42653 {
42654 resultobj = wxPyMake_wxObject(result, (bool)0);
42655 }
42656 return resultobj;
42657 fail:
42658 return NULL;
42659 }
42660
42661
42662 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42663 PyObject *resultobj = 0;
42664 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42665 bool result;
42666 void *argp1 = 0 ;
42667 int res1 = 0 ;
42668 PyObject *swig_obj[1] ;
42669
42670 if (!args) SWIG_fail;
42671 swig_obj[0] = args;
42672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42673 if (!SWIG_IsOK(res1)) {
42674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42675 }
42676 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 {
42684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42685 }
42686 return resultobj;
42687 fail:
42688 return NULL;
42689 }
42690
42691
42692 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42693 PyObject *resultobj = 0;
42694 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42695 wxFrame *arg2 = (wxFrame *) 0 ;
42696 void *argp1 = 0 ;
42697 int res1 = 0 ;
42698 void *argp2 = 0 ;
42699 int res2 = 0 ;
42700 PyObject * obj0 = 0 ;
42701 PyObject * obj1 = 0 ;
42702 char * kwnames[] = {
42703 (char *) "self",(char *) "frame", NULL
42704 };
42705
42706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42708 if (!SWIG_IsOK(res1)) {
42709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42710 }
42711 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42713 if (!SWIG_IsOK(res2)) {
42714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42715 }
42716 arg2 = reinterpret_cast< wxFrame * >(argp2);
42717 {
42718 PyThreadState* __tstate = wxPyBeginAllowThreads();
42719 (arg1)->Attach(arg2);
42720 wxPyEndAllowThreads(__tstate);
42721 if (PyErr_Occurred()) SWIG_fail;
42722 }
42723 resultobj = SWIG_Py_Void();
42724 return resultobj;
42725 fail:
42726 return NULL;
42727 }
42728
42729
42730 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42731 PyObject *resultobj = 0;
42732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42733 void *argp1 = 0 ;
42734 int res1 = 0 ;
42735 PyObject *swig_obj[1] ;
42736
42737 if (!args) SWIG_fail;
42738 swig_obj[0] = args;
42739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 (arg1)->Detach();
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 resultobj = SWIG_Py_Void();
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42758 PyObject *resultobj = 0;
42759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42760 void *argp1 = 0 ;
42761 int res1 = 0 ;
42762 PyObject *swig_obj[1] ;
42763
42764 if (!args) SWIG_fail;
42765 swig_obj[0] = args;
42766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42767 if (!SWIG_IsOK(res1)) {
42768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42769 }
42770 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42771 {
42772 PyThreadState* __tstate = wxPyBeginAllowThreads();
42773 (arg1)->UpdateMenus();
42774 wxPyEndAllowThreads(__tstate);
42775 if (PyErr_Occurred()) SWIG_fail;
42776 }
42777 resultobj = SWIG_Py_Void();
42778 return resultobj;
42779 fail:
42780 return NULL;
42781 }
42782
42783
42784 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42785 PyObject *resultobj = 0;
42786 bool arg1 ;
42787 bool val1 ;
42788 int ecode1 = 0 ;
42789 PyObject * obj0 = 0 ;
42790 char * kwnames[] = {
42791 (char *) "enable", NULL
42792 };
42793
42794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42795 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42796 if (!SWIG_IsOK(ecode1)) {
42797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42798 }
42799 arg1 = static_cast< bool >(val1);
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 wxMenuBar::SetAutoWindowMenu(arg1);
42803 wxPyEndAllowThreads(__tstate);
42804 if (PyErr_Occurred()) SWIG_fail;
42805 }
42806 resultobj = SWIG_Py_Void();
42807 return resultobj;
42808 fail:
42809 return NULL;
42810 }
42811
42812
42813 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42814 PyObject *resultobj = 0;
42815 bool result;
42816
42817 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = (bool)wxMenuBar::GetAutoWindowMenu();
42821 wxPyEndAllowThreads(__tstate);
42822 if (PyErr_Occurred()) SWIG_fail;
42823 }
42824 {
42825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42826 }
42827 return resultobj;
42828 fail:
42829 return NULL;
42830 }
42831
42832
42833 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42834 PyObject *obj;
42835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42836 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42837 return SWIG_Py_Void();
42838 }
42839
42840 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42841 return SWIG_Python_InitShadowInstance(args);
42842 }
42843
42844 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42845 PyObject *resultobj = 0;
42846 wxMenu *arg1 = (wxMenu *) NULL ;
42847 int arg2 = (int) wxID_ANY ;
42848 wxString const &arg3_defvalue = wxPyEmptyString ;
42849 wxString *arg3 = (wxString *) &arg3_defvalue ;
42850 wxString const &arg4_defvalue = wxPyEmptyString ;
42851 wxString *arg4 = (wxString *) &arg4_defvalue ;
42852 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42853 wxMenu *arg6 = (wxMenu *) NULL ;
42854 wxMenuItem *result = 0 ;
42855 void *argp1 = 0 ;
42856 int res1 = 0 ;
42857 int val2 ;
42858 int ecode2 = 0 ;
42859 bool temp3 = false ;
42860 bool temp4 = false ;
42861 int val5 ;
42862 int ecode5 = 0 ;
42863 void *argp6 = 0 ;
42864 int res6 = 0 ;
42865 PyObject * obj0 = 0 ;
42866 PyObject * obj1 = 0 ;
42867 PyObject * obj2 = 0 ;
42868 PyObject * obj3 = 0 ;
42869 PyObject * obj4 = 0 ;
42870 PyObject * obj5 = 0 ;
42871 char * kwnames[] = {
42872 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42873 };
42874
42875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42876 if (obj0) {
42877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42878 if (!SWIG_IsOK(res1)) {
42879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42880 }
42881 arg1 = reinterpret_cast< wxMenu * >(argp1);
42882 }
42883 if (obj1) {
42884 ecode2 = SWIG_AsVal_int(obj1, &val2);
42885 if (!SWIG_IsOK(ecode2)) {
42886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42887 }
42888 arg2 = static_cast< int >(val2);
42889 }
42890 if (obj2) {
42891 {
42892 arg3 = wxString_in_helper(obj2);
42893 if (arg3 == NULL) SWIG_fail;
42894 temp3 = true;
42895 }
42896 }
42897 if (obj3) {
42898 {
42899 arg4 = wxString_in_helper(obj3);
42900 if (arg4 == NULL) SWIG_fail;
42901 temp4 = true;
42902 }
42903 }
42904 if (obj4) {
42905 ecode5 = SWIG_AsVal_int(obj4, &val5);
42906 if (!SWIG_IsOK(ecode5)) {
42907 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42908 }
42909 arg5 = static_cast< wxItemKind >(val5);
42910 }
42911 if (obj5) {
42912 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42913 if (!SWIG_IsOK(res6)) {
42914 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42915 }
42916 arg6 = reinterpret_cast< wxMenu * >(argp6);
42917 }
42918 {
42919 PyThreadState* __tstate = wxPyBeginAllowThreads();
42920 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42921 wxPyEndAllowThreads(__tstate);
42922 if (PyErr_Occurred()) SWIG_fail;
42923 }
42924 {
42925 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42926 }
42927 {
42928 if (temp3)
42929 delete arg3;
42930 }
42931 {
42932 if (temp4)
42933 delete arg4;
42934 }
42935 return resultobj;
42936 fail:
42937 {
42938 if (temp3)
42939 delete arg3;
42940 }
42941 {
42942 if (temp4)
42943 delete arg4;
42944 }
42945 return NULL;
42946 }
42947
42948
42949 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42950 PyObject *resultobj = 0;
42951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42952 void *argp1 = 0 ;
42953 int res1 = 0 ;
42954 PyObject *swig_obj[1] ;
42955
42956 if (!args) SWIG_fail;
42957 swig_obj[0] = args;
42958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42959 if (!SWIG_IsOK(res1)) {
42960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42961 }
42962 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42963 {
42964 PyThreadState* __tstate = wxPyBeginAllowThreads();
42965 delete arg1;
42966
42967 wxPyEndAllowThreads(__tstate);
42968 if (PyErr_Occurred()) SWIG_fail;
42969 }
42970 resultobj = SWIG_Py_Void();
42971 return resultobj;
42972 fail:
42973 return NULL;
42974 }
42975
42976
42977 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42978 PyObject *resultobj = 0;
42979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42980 wxMenu *result = 0 ;
42981 void *argp1 = 0 ;
42982 int res1 = 0 ;
42983 PyObject *swig_obj[1] ;
42984
42985 if (!args) SWIG_fail;
42986 swig_obj[0] = args;
42987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42988 if (!SWIG_IsOK(res1)) {
42989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42990 }
42991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42992 {
42993 PyThreadState* __tstate = wxPyBeginAllowThreads();
42994 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42995 wxPyEndAllowThreads(__tstate);
42996 if (PyErr_Occurred()) SWIG_fail;
42997 }
42998 {
42999 resultobj = wxPyMake_wxObject(result, 0);
43000 }
43001 return resultobj;
43002 fail:
43003 return NULL;
43004 }
43005
43006
43007 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43008 PyObject *resultobj = 0;
43009 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43010 wxMenu *arg2 = (wxMenu *) 0 ;
43011 void *argp1 = 0 ;
43012 int res1 = 0 ;
43013 void *argp2 = 0 ;
43014 int res2 = 0 ;
43015 PyObject * obj0 = 0 ;
43016 PyObject * obj1 = 0 ;
43017 char * kwnames[] = {
43018 (char *) "self",(char *) "menu", NULL
43019 };
43020
43021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43023 if (!SWIG_IsOK(res1)) {
43024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43025 }
43026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43027 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43028 if (!SWIG_IsOK(res2)) {
43029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43030 }
43031 arg2 = reinterpret_cast< wxMenu * >(argp2);
43032 {
43033 PyThreadState* __tstate = wxPyBeginAllowThreads();
43034 (arg1)->SetMenu(arg2);
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 resultobj = SWIG_Py_Void();
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj = 0;
43047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43048 int arg2 ;
43049 void *argp1 = 0 ;
43050 int res1 = 0 ;
43051 int val2 ;
43052 int ecode2 = 0 ;
43053 PyObject * obj0 = 0 ;
43054 PyObject * obj1 = 0 ;
43055 char * kwnames[] = {
43056 (char *) "self",(char *) "id", NULL
43057 };
43058
43059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43061 if (!SWIG_IsOK(res1)) {
43062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43063 }
43064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43065 ecode2 = SWIG_AsVal_int(obj1, &val2);
43066 if (!SWIG_IsOK(ecode2)) {
43067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43068 }
43069 arg2 = static_cast< int >(val2);
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 (arg1)->SetId(arg2);
43073 wxPyEndAllowThreads(__tstate);
43074 if (PyErr_Occurred()) SWIG_fail;
43075 }
43076 resultobj = SWIG_Py_Void();
43077 return resultobj;
43078 fail:
43079 return NULL;
43080 }
43081
43082
43083 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43084 PyObject *resultobj = 0;
43085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43086 int result;
43087 void *argp1 = 0 ;
43088 int res1 = 0 ;
43089 PyObject *swig_obj[1] ;
43090
43091 if (!args) SWIG_fail;
43092 swig_obj[0] = args;
43093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43094 if (!SWIG_IsOK(res1)) {
43095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43096 }
43097 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 result = (int)((wxMenuItem const *)arg1)->GetId();
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 resultobj = SWIG_From_int(static_cast< int >(result));
43105 return resultobj;
43106 fail:
43107 return NULL;
43108 }
43109
43110
43111 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43112 PyObject *resultobj = 0;
43113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43114 bool result;
43115 void *argp1 = 0 ;
43116 int res1 = 0 ;
43117 PyObject *swig_obj[1] ;
43118
43119 if (!args) SWIG_fail;
43120 swig_obj[0] = args;
43121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43126 {
43127 PyThreadState* __tstate = wxPyBeginAllowThreads();
43128 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43134 }
43135 return resultobj;
43136 fail:
43137 return NULL;
43138 }
43139
43140
43141 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43142 PyObject *resultobj = 0;
43143 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43144 wxString *arg2 = 0 ;
43145 void *argp1 = 0 ;
43146 int res1 = 0 ;
43147 bool temp2 = false ;
43148 PyObject * obj0 = 0 ;
43149 PyObject * obj1 = 0 ;
43150 char * kwnames[] = {
43151 (char *) "self",(char *) "str", NULL
43152 };
43153
43154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43156 if (!SWIG_IsOK(res1)) {
43157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43158 }
43159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43160 {
43161 arg2 = wxString_in_helper(obj1);
43162 if (arg2 == NULL) SWIG_fail;
43163 temp2 = true;
43164 }
43165 {
43166 PyThreadState* __tstate = wxPyBeginAllowThreads();
43167 (arg1)->SetText((wxString const &)*arg2);
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 resultobj = SWIG_Py_Void();
43172 {
43173 if (temp2)
43174 delete arg2;
43175 }
43176 return resultobj;
43177 fail:
43178 {
43179 if (temp2)
43180 delete arg2;
43181 }
43182 return NULL;
43183 }
43184
43185
43186 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43187 PyObject *resultobj = 0;
43188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43189 wxString result;
43190 void *argp1 = 0 ;
43191 int res1 = 0 ;
43192 PyObject *swig_obj[1] ;
43193
43194 if (!args) SWIG_fail;
43195 swig_obj[0] = args;
43196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43197 if (!SWIG_IsOK(res1)) {
43198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43199 }
43200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43201 {
43202 PyThreadState* __tstate = wxPyBeginAllowThreads();
43203 result = ((wxMenuItem const *)arg1)->GetLabel();
43204 wxPyEndAllowThreads(__tstate);
43205 if (PyErr_Occurred()) SWIG_fail;
43206 }
43207 {
43208 #if wxUSE_UNICODE
43209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43210 #else
43211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43212 #endif
43213 }
43214 return resultobj;
43215 fail:
43216 return NULL;
43217 }
43218
43219
43220 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43221 PyObject *resultobj = 0;
43222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43223 wxString *result = 0 ;
43224 void *argp1 = 0 ;
43225 int res1 = 0 ;
43226 PyObject *swig_obj[1] ;
43227
43228 if (!args) SWIG_fail;
43229 swig_obj[0] = args;
43230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43231 if (!SWIG_IsOK(res1)) {
43232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43233 }
43234 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43235 {
43236 PyThreadState* __tstate = wxPyBeginAllowThreads();
43237 {
43238 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43239 result = (wxString *) &_result_ref;
43240 }
43241 wxPyEndAllowThreads(__tstate);
43242 if (PyErr_Occurred()) SWIG_fail;
43243 }
43244 {
43245 #if wxUSE_UNICODE
43246 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43247 #else
43248 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43249 #endif
43250 }
43251 return resultobj;
43252 fail:
43253 return NULL;
43254 }
43255
43256
43257 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43258 PyObject *resultobj = 0;
43259 wxString *arg1 = 0 ;
43260 wxString result;
43261 bool temp1 = false ;
43262 PyObject * obj0 = 0 ;
43263 char * kwnames[] = {
43264 (char *) "text", NULL
43265 };
43266
43267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43268 {
43269 arg1 = wxString_in_helper(obj0);
43270 if (arg1 == NULL) SWIG_fail;
43271 temp1 = true;
43272 }
43273 {
43274 PyThreadState* __tstate = wxPyBeginAllowThreads();
43275 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43276 wxPyEndAllowThreads(__tstate);
43277 if (PyErr_Occurred()) SWIG_fail;
43278 }
43279 {
43280 #if wxUSE_UNICODE
43281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43282 #else
43283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43284 #endif
43285 }
43286 {
43287 if (temp1)
43288 delete arg1;
43289 }
43290 return resultobj;
43291 fail:
43292 {
43293 if (temp1)
43294 delete arg1;
43295 }
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43301 PyObject *resultobj = 0;
43302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43303 wxItemKind result;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 PyObject *swig_obj[1] ;
43307
43308 if (!args) SWIG_fail;
43309 swig_obj[0] = args;
43310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43311 if (!SWIG_IsOK(res1)) {
43312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43313 }
43314 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43315 {
43316 PyThreadState* __tstate = wxPyBeginAllowThreads();
43317 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43318 wxPyEndAllowThreads(__tstate);
43319 if (PyErr_Occurred()) SWIG_fail;
43320 }
43321 resultobj = SWIG_From_int(static_cast< int >(result));
43322 return resultobj;
43323 fail:
43324 return NULL;
43325 }
43326
43327
43328 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43329 PyObject *resultobj = 0;
43330 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43331 wxItemKind arg2 ;
43332 void *argp1 = 0 ;
43333 int res1 = 0 ;
43334 int val2 ;
43335 int ecode2 = 0 ;
43336 PyObject * obj0 = 0 ;
43337 PyObject * obj1 = 0 ;
43338 char * kwnames[] = {
43339 (char *) "self",(char *) "kind", NULL
43340 };
43341
43342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43344 if (!SWIG_IsOK(res1)) {
43345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43346 }
43347 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43348 ecode2 = SWIG_AsVal_int(obj1, &val2);
43349 if (!SWIG_IsOK(ecode2)) {
43350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43351 }
43352 arg2 = static_cast< wxItemKind >(val2);
43353 {
43354 PyThreadState* __tstate = wxPyBeginAllowThreads();
43355 (arg1)->SetKind(arg2);
43356 wxPyEndAllowThreads(__tstate);
43357 if (PyErr_Occurred()) SWIG_fail;
43358 }
43359 resultobj = SWIG_Py_Void();
43360 return resultobj;
43361 fail:
43362 return NULL;
43363 }
43364
43365
43366 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43367 PyObject *resultobj = 0;
43368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43369 bool arg2 ;
43370 void *argp1 = 0 ;
43371 int res1 = 0 ;
43372 bool val2 ;
43373 int ecode2 = 0 ;
43374 PyObject * obj0 = 0 ;
43375 PyObject * obj1 = 0 ;
43376 char * kwnames[] = {
43377 (char *) "self",(char *) "checkable", NULL
43378 };
43379
43380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43382 if (!SWIG_IsOK(res1)) {
43383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43384 }
43385 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43386 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43387 if (!SWIG_IsOK(ecode2)) {
43388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43389 }
43390 arg2 = static_cast< bool >(val2);
43391 {
43392 PyThreadState* __tstate = wxPyBeginAllowThreads();
43393 (arg1)->SetCheckable(arg2);
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 resultobj = SWIG_Py_Void();
43398 return resultobj;
43399 fail:
43400 return NULL;
43401 }
43402
43403
43404 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43405 PyObject *resultobj = 0;
43406 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43407 bool result;
43408 void *argp1 = 0 ;
43409 int res1 = 0 ;
43410 PyObject *swig_obj[1] ;
43411
43412 if (!args) SWIG_fail;
43413 swig_obj[0] = args;
43414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43415 if (!SWIG_IsOK(res1)) {
43416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43417 }
43418 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43419 {
43420 PyThreadState* __tstate = wxPyBeginAllowThreads();
43421 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43422 wxPyEndAllowThreads(__tstate);
43423 if (PyErr_Occurred()) SWIG_fail;
43424 }
43425 {
43426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43427 }
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43435 PyObject *resultobj = 0;
43436 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43437 bool result;
43438 void *argp1 = 0 ;
43439 int res1 = 0 ;
43440 PyObject *swig_obj[1] ;
43441
43442 if (!args) SWIG_fail;
43443 swig_obj[0] = args;
43444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43445 if (!SWIG_IsOK(res1)) {
43446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43447 }
43448 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43449 {
43450 PyThreadState* __tstate = wxPyBeginAllowThreads();
43451 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43452 wxPyEndAllowThreads(__tstate);
43453 if (PyErr_Occurred()) SWIG_fail;
43454 }
43455 {
43456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43457 }
43458 return resultobj;
43459 fail:
43460 return NULL;
43461 }
43462
43463
43464 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43465 PyObject *resultobj = 0;
43466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43467 wxMenu *arg2 = (wxMenu *) 0 ;
43468 void *argp1 = 0 ;
43469 int res1 = 0 ;
43470 void *argp2 = 0 ;
43471 int res2 = 0 ;
43472 PyObject * obj0 = 0 ;
43473 PyObject * obj1 = 0 ;
43474 char * kwnames[] = {
43475 (char *) "self",(char *) "menu", NULL
43476 };
43477
43478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res1)) {
43481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43482 }
43483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43485 if (!SWIG_IsOK(res2)) {
43486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43487 }
43488 arg2 = reinterpret_cast< wxMenu * >(argp2);
43489 {
43490 PyThreadState* __tstate = wxPyBeginAllowThreads();
43491 (arg1)->SetSubMenu(arg2);
43492 wxPyEndAllowThreads(__tstate);
43493 if (PyErr_Occurred()) SWIG_fail;
43494 }
43495 resultobj = SWIG_Py_Void();
43496 return resultobj;
43497 fail:
43498 return NULL;
43499 }
43500
43501
43502 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43503 PyObject *resultobj = 0;
43504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43505 wxMenu *result = 0 ;
43506 void *argp1 = 0 ;
43507 int res1 = 0 ;
43508 PyObject *swig_obj[1] ;
43509
43510 if (!args) SWIG_fail;
43511 swig_obj[0] = args;
43512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43513 if (!SWIG_IsOK(res1)) {
43514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43515 }
43516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43517 {
43518 PyThreadState* __tstate = wxPyBeginAllowThreads();
43519 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43520 wxPyEndAllowThreads(__tstate);
43521 if (PyErr_Occurred()) SWIG_fail;
43522 }
43523 {
43524 resultobj = wxPyMake_wxObject(result, 0);
43525 }
43526 return resultobj;
43527 fail:
43528 return NULL;
43529 }
43530
43531
43532 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43533 PyObject *resultobj = 0;
43534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43535 bool arg2 = (bool) true ;
43536 void *argp1 = 0 ;
43537 int res1 = 0 ;
43538 bool val2 ;
43539 int ecode2 = 0 ;
43540 PyObject * obj0 = 0 ;
43541 PyObject * obj1 = 0 ;
43542 char * kwnames[] = {
43543 (char *) "self",(char *) "enable", NULL
43544 };
43545
43546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43548 if (!SWIG_IsOK(res1)) {
43549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43550 }
43551 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43552 if (obj1) {
43553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43554 if (!SWIG_IsOK(ecode2)) {
43555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43556 }
43557 arg2 = static_cast< bool >(val2);
43558 }
43559 {
43560 PyThreadState* __tstate = wxPyBeginAllowThreads();
43561 (arg1)->Enable(arg2);
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 resultobj = SWIG_Py_Void();
43566 return resultobj;
43567 fail:
43568 return NULL;
43569 }
43570
43571
43572 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43573 PyObject *resultobj = 0;
43574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43575 bool result;
43576 void *argp1 = 0 ;
43577 int res1 = 0 ;
43578 PyObject *swig_obj[1] ;
43579
43580 if (!args) SWIG_fail;
43581 swig_obj[0] = args;
43582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43583 if (!SWIG_IsOK(res1)) {
43584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43585 }
43586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43590 wxPyEndAllowThreads(__tstate);
43591 if (PyErr_Occurred()) SWIG_fail;
43592 }
43593 {
43594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43595 }
43596 return resultobj;
43597 fail:
43598 return NULL;
43599 }
43600
43601
43602 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43603 PyObject *resultobj = 0;
43604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43605 bool arg2 = (bool) true ;
43606 void *argp1 = 0 ;
43607 int res1 = 0 ;
43608 bool val2 ;
43609 int ecode2 = 0 ;
43610 PyObject * obj0 = 0 ;
43611 PyObject * obj1 = 0 ;
43612 char * kwnames[] = {
43613 (char *) "self",(char *) "check", NULL
43614 };
43615
43616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43618 if (!SWIG_IsOK(res1)) {
43619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43620 }
43621 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43622 if (obj1) {
43623 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43624 if (!SWIG_IsOK(ecode2)) {
43625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43626 }
43627 arg2 = static_cast< bool >(val2);
43628 }
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 (arg1)->Check(arg2);
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 resultobj = SWIG_Py_Void();
43636 return resultobj;
43637 fail:
43638 return NULL;
43639 }
43640
43641
43642 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43643 PyObject *resultobj = 0;
43644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43645 bool result;
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, 0 | 0 );
43653 if (!SWIG_IsOK(res1)) {
43654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43655 }
43656 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43660 wxPyEndAllowThreads(__tstate);
43661 if (PyErr_Occurred()) SWIG_fail;
43662 }
43663 {
43664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43665 }
43666 return resultobj;
43667 fail:
43668 return NULL;
43669 }
43670
43671
43672 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43673 PyObject *resultobj = 0;
43674 wxMenuItem *arg1 = (wxMenuItem *) 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_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43684 }
43685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 (arg1)->Toggle();
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 resultobj = SWIG_Py_Void();
43693 return resultobj;
43694 fail:
43695 return NULL;
43696 }
43697
43698
43699 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43700 PyObject *resultobj = 0;
43701 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43702 wxString *arg2 = 0 ;
43703 void *argp1 = 0 ;
43704 int res1 = 0 ;
43705 bool temp2 = false ;
43706 PyObject * obj0 = 0 ;
43707 PyObject * obj1 = 0 ;
43708 char * kwnames[] = {
43709 (char *) "self",(char *) "str", NULL
43710 };
43711
43712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43714 if (!SWIG_IsOK(res1)) {
43715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43716 }
43717 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43718 {
43719 arg2 = wxString_in_helper(obj1);
43720 if (arg2 == NULL) SWIG_fail;
43721 temp2 = true;
43722 }
43723 {
43724 PyThreadState* __tstate = wxPyBeginAllowThreads();
43725 (arg1)->SetHelp((wxString const &)*arg2);
43726 wxPyEndAllowThreads(__tstate);
43727 if (PyErr_Occurred()) SWIG_fail;
43728 }
43729 resultobj = SWIG_Py_Void();
43730 {
43731 if (temp2)
43732 delete arg2;
43733 }
43734 return resultobj;
43735 fail:
43736 {
43737 if (temp2)
43738 delete arg2;
43739 }
43740 return NULL;
43741 }
43742
43743
43744 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43745 PyObject *resultobj = 0;
43746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43747 wxString *result = 0 ;
43748 void *argp1 = 0 ;
43749 int res1 = 0 ;
43750 PyObject *swig_obj[1] ;
43751
43752 if (!args) SWIG_fail;
43753 swig_obj[0] = args;
43754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43759 {
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 {
43762 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43763 result = (wxString *) &_result_ref;
43764 }
43765 wxPyEndAllowThreads(__tstate);
43766 if (PyErr_Occurred()) SWIG_fail;
43767 }
43768 {
43769 #if wxUSE_UNICODE
43770 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43771 #else
43772 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43773 #endif
43774 }
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43782 PyObject *resultobj = 0;
43783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43784 wxAcceleratorEntry *result = 0 ;
43785 void *argp1 = 0 ;
43786 int res1 = 0 ;
43787 PyObject *swig_obj[1] ;
43788
43789 if (!args) SWIG_fail;
43790 swig_obj[0] = args;
43791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43792 if (!SWIG_IsOK(res1)) {
43793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43794 }
43795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43796 {
43797 PyThreadState* __tstate = wxPyBeginAllowThreads();
43798 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43799 wxPyEndAllowThreads(__tstate);
43800 if (PyErr_Occurred()) SWIG_fail;
43801 }
43802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43810 PyObject *resultobj = 0;
43811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43812 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43813 void *argp1 = 0 ;
43814 int res1 = 0 ;
43815 void *argp2 = 0 ;
43816 int res2 = 0 ;
43817 PyObject * obj0 = 0 ;
43818 PyObject * obj1 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "accel", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43827 }
43828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43830 if (!SWIG_IsOK(res2)) {
43831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43832 }
43833 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->SetAccel(arg2);
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 return resultobj;
43842 fail:
43843 return NULL;
43844 }
43845
43846
43847 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43848 PyObject *resultobj = 0;
43849 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43850 wxBitmap *arg2 = 0 ;
43851 void *argp1 = 0 ;
43852 int res1 = 0 ;
43853 void *argp2 = 0 ;
43854 int res2 = 0 ;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857 char * kwnames[] = {
43858 (char *) "self",(char *) "bitmap", NULL
43859 };
43860
43861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43863 if (!SWIG_IsOK(res1)) {
43864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43865 }
43866 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43867 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43868 if (!SWIG_IsOK(res2)) {
43869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43870 }
43871 if (!argp2) {
43872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43873 }
43874 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43875 {
43876 PyThreadState* __tstate = wxPyBeginAllowThreads();
43877 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43878 wxPyEndAllowThreads(__tstate);
43879 if (PyErr_Occurred()) SWIG_fail;
43880 }
43881 resultobj = SWIG_Py_Void();
43882 return resultobj;
43883 fail:
43884 return NULL;
43885 }
43886
43887
43888 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43889 PyObject *resultobj = 0;
43890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43891 wxBitmap *result = 0 ;
43892 void *argp1 = 0 ;
43893 int res1 = 0 ;
43894 PyObject *swig_obj[1] ;
43895
43896 if (!args) SWIG_fail;
43897 swig_obj[0] = args;
43898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43899 if (!SWIG_IsOK(res1)) {
43900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43901 }
43902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 {
43906 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43907 result = (wxBitmap *) &_result_ref;
43908 }
43909 wxPyEndAllowThreads(__tstate);
43910 if (PyErr_Occurred()) SWIG_fail;
43911 }
43912 {
43913 wxBitmap* resultptr = new wxBitmap(*result);
43914 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43915 }
43916 return resultobj;
43917 fail:
43918 return NULL;
43919 }
43920
43921
43922 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43923 PyObject *resultobj = 0;
43924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43925 wxFont *arg2 = 0 ;
43926 void *argp1 = 0 ;
43927 int res1 = 0 ;
43928 void *argp2 = 0 ;
43929 int res2 = 0 ;
43930 PyObject * obj0 = 0 ;
43931 PyObject * obj1 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "self",(char *) "font", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43938 if (!SWIG_IsOK(res1)) {
43939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43940 }
43941 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43943 if (!SWIG_IsOK(res2)) {
43944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43945 }
43946 if (!argp2) {
43947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43948 }
43949 arg2 = reinterpret_cast< wxFont * >(argp2);
43950 {
43951 PyThreadState* __tstate = wxPyBeginAllowThreads();
43952 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43953 wxPyEndAllowThreads(__tstate);
43954 if (PyErr_Occurred()) SWIG_fail;
43955 }
43956 resultobj = SWIG_Py_Void();
43957 return resultobj;
43958 fail:
43959 return NULL;
43960 }
43961
43962
43963 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43964 PyObject *resultobj = 0;
43965 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43966 wxFont result;
43967 void *argp1 = 0 ;
43968 int res1 = 0 ;
43969 PyObject *swig_obj[1] ;
43970
43971 if (!args) SWIG_fail;
43972 swig_obj[0] = args;
43973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43974 if (!SWIG_IsOK(res1)) {
43975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43976 }
43977 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 result = wxMenuItem_GetFont(arg1);
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43992 PyObject *resultobj = 0;
43993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43994 wxColour *arg2 = 0 ;
43995 void *argp1 = 0 ;
43996 int res1 = 0 ;
43997 wxColour temp2 ;
43998 PyObject * obj0 = 0 ;
43999 PyObject * obj1 = 0 ;
44000 char * kwnames[] = {
44001 (char *) "self",(char *) "colText", NULL
44002 };
44003
44004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44006 if (!SWIG_IsOK(res1)) {
44007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44008 }
44009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44010 {
44011 arg2 = &temp2;
44012 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44013 }
44014 {
44015 PyThreadState* __tstate = wxPyBeginAllowThreads();
44016 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 resultobj = SWIG_Py_Void();
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44028 PyObject *resultobj = 0;
44029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44030 wxColour result;
44031 void *argp1 = 0 ;
44032 int res1 = 0 ;
44033 PyObject *swig_obj[1] ;
44034
44035 if (!args) SWIG_fail;
44036 swig_obj[0] = args;
44037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44038 if (!SWIG_IsOK(res1)) {
44039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44040 }
44041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44042 {
44043 PyThreadState* __tstate = wxPyBeginAllowThreads();
44044 result = wxMenuItem_GetTextColour(arg1);
44045 wxPyEndAllowThreads(__tstate);
44046 if (PyErr_Occurred()) SWIG_fail;
44047 }
44048 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44049 return resultobj;
44050 fail:
44051 return NULL;
44052 }
44053
44054
44055 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44056 PyObject *resultobj = 0;
44057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44058 wxColour *arg2 = 0 ;
44059 void *argp1 = 0 ;
44060 int res1 = 0 ;
44061 wxColour temp2 ;
44062 PyObject * obj0 = 0 ;
44063 PyObject * obj1 = 0 ;
44064 char * kwnames[] = {
44065 (char *) "self",(char *) "colBack", NULL
44066 };
44067
44068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44070 if (!SWIG_IsOK(res1)) {
44071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44072 }
44073 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44074 {
44075 arg2 = &temp2;
44076 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44077 }
44078 {
44079 PyThreadState* __tstate = wxPyBeginAllowThreads();
44080 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44081 wxPyEndAllowThreads(__tstate);
44082 if (PyErr_Occurred()) SWIG_fail;
44083 }
44084 resultobj = SWIG_Py_Void();
44085 return resultobj;
44086 fail:
44087 return NULL;
44088 }
44089
44090
44091 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44092 PyObject *resultobj = 0;
44093 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44094 wxColour result;
44095 void *argp1 = 0 ;
44096 int res1 = 0 ;
44097 PyObject *swig_obj[1] ;
44098
44099 if (!args) SWIG_fail;
44100 swig_obj[0] = args;
44101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44102 if (!SWIG_IsOK(res1)) {
44103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44104 }
44105 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 result = wxMenuItem_GetBackgroundColour(arg1);
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44120 PyObject *resultobj = 0;
44121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44122 wxBitmap *arg2 = 0 ;
44123 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44124 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44125 void *argp1 = 0 ;
44126 int res1 = 0 ;
44127 void *argp2 = 0 ;
44128 int res2 = 0 ;
44129 void *argp3 = 0 ;
44130 int res3 = 0 ;
44131 PyObject * obj0 = 0 ;
44132 PyObject * obj1 = 0 ;
44133 PyObject * obj2 = 0 ;
44134 char * kwnames[] = {
44135 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44136 };
44137
44138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44140 if (!SWIG_IsOK(res1)) {
44141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44142 }
44143 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44144 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44145 if (!SWIG_IsOK(res2)) {
44146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44147 }
44148 if (!argp2) {
44149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44150 }
44151 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44152 if (obj2) {
44153 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44154 if (!SWIG_IsOK(res3)) {
44155 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44156 }
44157 if (!argp3) {
44158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44159 }
44160 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44161 }
44162 {
44163 PyThreadState* __tstate = wxPyBeginAllowThreads();
44164 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44165 wxPyEndAllowThreads(__tstate);
44166 if (PyErr_Occurred()) SWIG_fail;
44167 }
44168 resultobj = SWIG_Py_Void();
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = 0;
44177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44178 wxBitmap *arg2 = 0 ;
44179 void *argp1 = 0 ;
44180 int res1 = 0 ;
44181 void *argp2 = 0 ;
44182 int res2 = 0 ;
44183 PyObject * obj0 = 0 ;
44184 PyObject * obj1 = 0 ;
44185 char * kwnames[] = {
44186 (char *) "self",(char *) "bmpDisabled", NULL
44187 };
44188
44189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44191 if (!SWIG_IsOK(res1)) {
44192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44193 }
44194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44196 if (!SWIG_IsOK(res2)) {
44197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44198 }
44199 if (!argp2) {
44200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44201 }
44202 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44203 {
44204 PyThreadState* __tstate = wxPyBeginAllowThreads();
44205 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44206 wxPyEndAllowThreads(__tstate);
44207 if (PyErr_Occurred()) SWIG_fail;
44208 }
44209 resultobj = SWIG_Py_Void();
44210 return resultobj;
44211 fail:
44212 return NULL;
44213 }
44214
44215
44216 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44217 PyObject *resultobj = 0;
44218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44219 wxBitmap *result = 0 ;
44220 void *argp1 = 0 ;
44221 int res1 = 0 ;
44222 PyObject *swig_obj[1] ;
44223
44224 if (!args) SWIG_fail;
44225 swig_obj[0] = args;
44226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44227 if (!SWIG_IsOK(res1)) {
44228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44229 }
44230 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44231 {
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 {
44234 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44235 result = (wxBitmap *) &_result_ref;
44236 }
44237 wxPyEndAllowThreads(__tstate);
44238 if (PyErr_Occurred()) SWIG_fail;
44239 }
44240 {
44241 wxBitmap* resultptr = new wxBitmap(*result);
44242 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44243 }
44244 return resultobj;
44245 fail:
44246 return NULL;
44247 }
44248
44249
44250 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44251 PyObject *resultobj = 0;
44252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44253 int arg2 ;
44254 void *argp1 = 0 ;
44255 int res1 = 0 ;
44256 int val2 ;
44257 int ecode2 = 0 ;
44258 PyObject * obj0 = 0 ;
44259 PyObject * obj1 = 0 ;
44260 char * kwnames[] = {
44261 (char *) "self",(char *) "nWidth", NULL
44262 };
44263
44264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44266 if (!SWIG_IsOK(res1)) {
44267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44268 }
44269 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44270 ecode2 = SWIG_AsVal_int(obj1, &val2);
44271 if (!SWIG_IsOK(ecode2)) {
44272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44273 }
44274 arg2 = static_cast< int >(val2);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 wxMenuItem_SetMarginWidth(arg1,arg2);
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 resultobj = SWIG_Py_Void();
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44289 PyObject *resultobj = 0;
44290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44291 int result;
44292 void *argp1 = 0 ;
44293 int res1 = 0 ;
44294 PyObject *swig_obj[1] ;
44295
44296 if (!args) SWIG_fail;
44297 swig_obj[0] = args;
44298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44299 if (!SWIG_IsOK(res1)) {
44300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44301 }
44302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44303 {
44304 PyThreadState* __tstate = wxPyBeginAllowThreads();
44305 result = (int)wxMenuItem_GetMarginWidth(arg1);
44306 wxPyEndAllowThreads(__tstate);
44307 if (PyErr_Occurred()) SWIG_fail;
44308 }
44309 resultobj = SWIG_From_int(static_cast< int >(result));
44310 return resultobj;
44311 fail:
44312 return NULL;
44313 }
44314
44315
44316 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44317 PyObject *resultobj = 0;
44318 int result;
44319
44320 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44321 {
44322 PyThreadState* __tstate = wxPyBeginAllowThreads();
44323 result = (int)wxMenuItem_GetDefaultMarginWidth();
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 resultobj = SWIG_From_int(static_cast< int >(result));
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44335 PyObject *resultobj = 0;
44336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44337 bool result;
44338 void *argp1 = 0 ;
44339 int res1 = 0 ;
44340 PyObject *swig_obj[1] ;
44341
44342 if (!args) SWIG_fail;
44343 swig_obj[0] = args;
44344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44345 if (!SWIG_IsOK(res1)) {
44346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44347 }
44348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44349 {
44350 PyThreadState* __tstate = wxPyBeginAllowThreads();
44351 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44352 wxPyEndAllowThreads(__tstate);
44353 if (PyErr_Occurred()) SWIG_fail;
44354 }
44355 {
44356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44357 }
44358 return resultobj;
44359 fail:
44360 return NULL;
44361 }
44362
44363
44364 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44365 PyObject *resultobj = 0;
44366 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44367 bool arg2 = (bool) true ;
44368 void *argp1 = 0 ;
44369 int res1 = 0 ;
44370 bool val2 ;
44371 int ecode2 = 0 ;
44372 PyObject * obj0 = 0 ;
44373 PyObject * obj1 = 0 ;
44374 char * kwnames[] = {
44375 (char *) "self",(char *) "ownerDrawn", NULL
44376 };
44377
44378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44380 if (!SWIG_IsOK(res1)) {
44381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44382 }
44383 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44384 if (obj1) {
44385 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44386 if (!SWIG_IsOK(ecode2)) {
44387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44388 }
44389 arg2 = static_cast< bool >(val2);
44390 }
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44394 wxPyEndAllowThreads(__tstate);
44395 if (PyErr_Occurred()) SWIG_fail;
44396 }
44397 resultobj = SWIG_Py_Void();
44398 return resultobj;
44399 fail:
44400 return NULL;
44401 }
44402
44403
44404 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44405 PyObject *resultobj = 0;
44406 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44407 void *argp1 = 0 ;
44408 int res1 = 0 ;
44409 PyObject *swig_obj[1] ;
44410
44411 if (!args) SWIG_fail;
44412 swig_obj[0] = args;
44413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44414 if (!SWIG_IsOK(res1)) {
44415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44416 }
44417 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44418 {
44419 PyThreadState* __tstate = wxPyBeginAllowThreads();
44420 wxMenuItem_ResetOwnerDrawn(arg1);
44421 wxPyEndAllowThreads(__tstate);
44422 if (PyErr_Occurred()) SWIG_fail;
44423 }
44424 resultobj = SWIG_Py_Void();
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44432 PyObject *obj;
44433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44434 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44435 return SWIG_Py_Void();
44436 }
44437
44438 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44439 return SWIG_Python_InitShadowInstance(args);
44440 }
44441
44442 SWIGINTERN int ControlNameStr_set(PyObject *) {
44443 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44444 return 1;
44445 }
44446
44447
44448 SWIGINTERN PyObject *ControlNameStr_get(void) {
44449 PyObject *pyobj = 0;
44450
44451 {
44452 #if wxUSE_UNICODE
44453 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44454 #else
44455 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44456 #endif
44457 }
44458 return pyobj;
44459 }
44460
44461
44462 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj = 0;
44464 wxWindow *arg1 = (wxWindow *) 0 ;
44465 int arg2 = (int) -1 ;
44466 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44467 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44468 wxSize const &arg4_defvalue = wxDefaultSize ;
44469 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44470 long arg5 = (long) 0 ;
44471 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44472 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44473 wxString const &arg7_defvalue = wxPyControlNameStr ;
44474 wxString *arg7 = (wxString *) &arg7_defvalue ;
44475 wxControl *result = 0 ;
44476 void *argp1 = 0 ;
44477 int res1 = 0 ;
44478 int val2 ;
44479 int ecode2 = 0 ;
44480 wxPoint temp3 ;
44481 wxSize temp4 ;
44482 long val5 ;
44483 int ecode5 = 0 ;
44484 void *argp6 = 0 ;
44485 int res6 = 0 ;
44486 bool temp7 = false ;
44487 PyObject * obj0 = 0 ;
44488 PyObject * obj1 = 0 ;
44489 PyObject * obj2 = 0 ;
44490 PyObject * obj3 = 0 ;
44491 PyObject * obj4 = 0 ;
44492 PyObject * obj5 = 0 ;
44493 PyObject * obj6 = 0 ;
44494 char * kwnames[] = {
44495 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44496 };
44497
44498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44502 }
44503 arg1 = reinterpret_cast< wxWindow * >(argp1);
44504 if (obj1) {
44505 ecode2 = SWIG_AsVal_int(obj1, &val2);
44506 if (!SWIG_IsOK(ecode2)) {
44507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44508 }
44509 arg2 = static_cast< int >(val2);
44510 }
44511 if (obj2) {
44512 {
44513 arg3 = &temp3;
44514 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44515 }
44516 }
44517 if (obj3) {
44518 {
44519 arg4 = &temp4;
44520 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44521 }
44522 }
44523 if (obj4) {
44524 ecode5 = SWIG_AsVal_long(obj4, &val5);
44525 if (!SWIG_IsOK(ecode5)) {
44526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44527 }
44528 arg5 = static_cast< long >(val5);
44529 }
44530 if (obj5) {
44531 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44532 if (!SWIG_IsOK(res6)) {
44533 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44534 }
44535 if (!argp6) {
44536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44537 }
44538 arg6 = reinterpret_cast< wxValidator * >(argp6);
44539 }
44540 if (obj6) {
44541 {
44542 arg7 = wxString_in_helper(obj6);
44543 if (arg7 == NULL) SWIG_fail;
44544 temp7 = true;
44545 }
44546 }
44547 {
44548 if (!wxPyCheckForApp()) SWIG_fail;
44549 PyThreadState* __tstate = wxPyBeginAllowThreads();
44550 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44551 wxPyEndAllowThreads(__tstate);
44552 if (PyErr_Occurred()) SWIG_fail;
44553 }
44554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44555 {
44556 if (temp7)
44557 delete arg7;
44558 }
44559 return resultobj;
44560 fail:
44561 {
44562 if (temp7)
44563 delete arg7;
44564 }
44565 return NULL;
44566 }
44567
44568
44569 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44570 PyObject *resultobj = 0;
44571 wxControl *result = 0 ;
44572
44573 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44574 {
44575 if (!wxPyCheckForApp()) SWIG_fail;
44576 PyThreadState* __tstate = wxPyBeginAllowThreads();
44577 result = (wxControl *)new wxControl();
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44582 return resultobj;
44583 fail:
44584 return NULL;
44585 }
44586
44587
44588 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44589 PyObject *resultobj = 0;
44590 wxControl *arg1 = (wxControl *) 0 ;
44591 wxWindow *arg2 = (wxWindow *) 0 ;
44592 int arg3 = (int) -1 ;
44593 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44594 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44595 wxSize const &arg5_defvalue = wxDefaultSize ;
44596 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44597 long arg6 = (long) 0 ;
44598 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44599 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44600 wxString const &arg8_defvalue = wxPyControlNameStr ;
44601 wxString *arg8 = (wxString *) &arg8_defvalue ;
44602 bool result;
44603 void *argp1 = 0 ;
44604 int res1 = 0 ;
44605 void *argp2 = 0 ;
44606 int res2 = 0 ;
44607 int val3 ;
44608 int ecode3 = 0 ;
44609 wxPoint temp4 ;
44610 wxSize temp5 ;
44611 long val6 ;
44612 int ecode6 = 0 ;
44613 void *argp7 = 0 ;
44614 int res7 = 0 ;
44615 bool temp8 = false ;
44616 PyObject * obj0 = 0 ;
44617 PyObject * obj1 = 0 ;
44618 PyObject * obj2 = 0 ;
44619 PyObject * obj3 = 0 ;
44620 PyObject * obj4 = 0 ;
44621 PyObject * obj5 = 0 ;
44622 PyObject * obj6 = 0 ;
44623 PyObject * obj7 = 0 ;
44624 char * kwnames[] = {
44625 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44626 };
44627
44628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44630 if (!SWIG_IsOK(res1)) {
44631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44632 }
44633 arg1 = reinterpret_cast< wxControl * >(argp1);
44634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44635 if (!SWIG_IsOK(res2)) {
44636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44637 }
44638 arg2 = reinterpret_cast< wxWindow * >(argp2);
44639 if (obj2) {
44640 ecode3 = SWIG_AsVal_int(obj2, &val3);
44641 if (!SWIG_IsOK(ecode3)) {
44642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44643 }
44644 arg3 = static_cast< int >(val3);
44645 }
44646 if (obj3) {
44647 {
44648 arg4 = &temp4;
44649 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44650 }
44651 }
44652 if (obj4) {
44653 {
44654 arg5 = &temp5;
44655 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44656 }
44657 }
44658 if (obj5) {
44659 ecode6 = SWIG_AsVal_long(obj5, &val6);
44660 if (!SWIG_IsOK(ecode6)) {
44661 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44662 }
44663 arg6 = static_cast< long >(val6);
44664 }
44665 if (obj6) {
44666 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44667 if (!SWIG_IsOK(res7)) {
44668 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44669 }
44670 if (!argp7) {
44671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44672 }
44673 arg7 = reinterpret_cast< wxValidator * >(argp7);
44674 }
44675 if (obj7) {
44676 {
44677 arg8 = wxString_in_helper(obj7);
44678 if (arg8 == NULL) SWIG_fail;
44679 temp8 = true;
44680 }
44681 }
44682 {
44683 PyThreadState* __tstate = wxPyBeginAllowThreads();
44684 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44685 wxPyEndAllowThreads(__tstate);
44686 if (PyErr_Occurred()) SWIG_fail;
44687 }
44688 {
44689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44690 }
44691 {
44692 if (temp8)
44693 delete arg8;
44694 }
44695 return resultobj;
44696 fail:
44697 {
44698 if (temp8)
44699 delete arg8;
44700 }
44701 return NULL;
44702 }
44703
44704
44705 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44706 PyObject *resultobj = 0;
44707 wxControl *arg1 = (wxControl *) 0 ;
44708 int result;
44709 void *argp1 = 0 ;
44710 int res1 = 0 ;
44711 PyObject *swig_obj[1] ;
44712
44713 if (!args) SWIG_fail;
44714 swig_obj[0] = args;
44715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44716 if (!SWIG_IsOK(res1)) {
44717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44718 }
44719 arg1 = reinterpret_cast< wxControl * >(argp1);
44720 {
44721 PyThreadState* __tstate = wxPyBeginAllowThreads();
44722 result = (int)((wxControl const *)arg1)->GetAlignment();
44723 wxPyEndAllowThreads(__tstate);
44724 if (PyErr_Occurred()) SWIG_fail;
44725 }
44726 resultobj = SWIG_From_int(static_cast< int >(result));
44727 return resultobj;
44728 fail:
44729 return NULL;
44730 }
44731
44732
44733 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44734 PyObject *resultobj = 0;
44735 wxControl *arg1 = (wxControl *) 0 ;
44736 wxString result;
44737 void *argp1 = 0 ;
44738 int res1 = 0 ;
44739 PyObject *swig_obj[1] ;
44740
44741 if (!args) SWIG_fail;
44742 swig_obj[0] = args;
44743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44744 if (!SWIG_IsOK(res1)) {
44745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44746 }
44747 arg1 = reinterpret_cast< wxControl * >(argp1);
44748 {
44749 PyThreadState* __tstate = wxPyBeginAllowThreads();
44750 result = ((wxControl const *)arg1)->GetLabelText();
44751 wxPyEndAllowThreads(__tstate);
44752 if (PyErr_Occurred()) SWIG_fail;
44753 }
44754 {
44755 #if wxUSE_UNICODE
44756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44757 #else
44758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44759 #endif
44760 }
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44768 PyObject *resultobj = 0;
44769 wxControl *arg1 = (wxControl *) 0 ;
44770 wxCommandEvent *arg2 = 0 ;
44771 void *argp1 = 0 ;
44772 int res1 = 0 ;
44773 void *argp2 = 0 ;
44774 int res2 = 0 ;
44775 PyObject * obj0 = 0 ;
44776 PyObject * obj1 = 0 ;
44777 char * kwnames[] = {
44778 (char *) "self",(char *) "event", NULL
44779 };
44780
44781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44783 if (!SWIG_IsOK(res1)) {
44784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44785 }
44786 arg1 = reinterpret_cast< wxControl * >(argp1);
44787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44788 if (!SWIG_IsOK(res2)) {
44789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44790 }
44791 if (!argp2) {
44792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44793 }
44794 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44795 {
44796 PyThreadState* __tstate = wxPyBeginAllowThreads();
44797 (arg1)->Command(*arg2);
44798 wxPyEndAllowThreads(__tstate);
44799 if (PyErr_Occurred()) SWIG_fail;
44800 }
44801 resultobj = SWIG_Py_Void();
44802 return resultobj;
44803 fail:
44804 return NULL;
44805 }
44806
44807
44808 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44809 PyObject *resultobj = 0;
44810 wxControl *arg1 = (wxControl *) 0 ;
44811 wxString result;
44812 void *argp1 = 0 ;
44813 int res1 = 0 ;
44814 PyObject *swig_obj[1] ;
44815
44816 if (!args) SWIG_fail;
44817 swig_obj[0] = args;
44818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44819 if (!SWIG_IsOK(res1)) {
44820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44821 }
44822 arg1 = reinterpret_cast< wxControl * >(argp1);
44823 {
44824 PyThreadState* __tstate = wxPyBeginAllowThreads();
44825 result = (arg1)->GetLabel();
44826 wxPyEndAllowThreads(__tstate);
44827 if (PyErr_Occurred()) SWIG_fail;
44828 }
44829 {
44830 #if wxUSE_UNICODE
44831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44832 #else
44833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44834 #endif
44835 }
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44843 PyObject *resultobj = 0;
44844 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44845 SwigValueWrapper<wxVisualAttributes > result;
44846 int val1 ;
44847 int ecode1 = 0 ;
44848 PyObject * obj0 = 0 ;
44849 char * kwnames[] = {
44850 (char *) "variant", NULL
44851 };
44852
44853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44854 if (obj0) {
44855 ecode1 = SWIG_AsVal_int(obj0, &val1);
44856 if (!SWIG_IsOK(ecode1)) {
44857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44858 }
44859 arg1 = static_cast< wxWindowVariant >(val1);
44860 }
44861 {
44862 if (!wxPyCheckForApp()) SWIG_fail;
44863 PyThreadState* __tstate = wxPyBeginAllowThreads();
44864 result = wxControl::GetClassDefaultAttributes(arg1);
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44869 return resultobj;
44870 fail:
44871 return NULL;
44872 }
44873
44874
44875 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44876 PyObject *obj;
44877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44878 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44879 return SWIG_Py_Void();
44880 }
44881
44882 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44883 return SWIG_Python_InitShadowInstance(args);
44884 }
44885
44886 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44887 PyObject *resultobj = 0;
44888 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44889 wxString *arg2 = 0 ;
44890 PyObject *arg3 = (PyObject *) NULL ;
44891 int result;
44892 void *argp1 = 0 ;
44893 int res1 = 0 ;
44894 bool temp2 = false ;
44895 PyObject * obj0 = 0 ;
44896 PyObject * obj1 = 0 ;
44897 PyObject * obj2 = 0 ;
44898 char * kwnames[] = {
44899 (char *) "self",(char *) "item",(char *) "clientData", NULL
44900 };
44901
44902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44904 if (!SWIG_IsOK(res1)) {
44905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44906 }
44907 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44908 {
44909 arg2 = wxString_in_helper(obj1);
44910 if (arg2 == NULL) SWIG_fail;
44911 temp2 = true;
44912 }
44913 if (obj2) {
44914 arg3 = obj2;
44915 }
44916 {
44917 PyThreadState* __tstate = wxPyBeginAllowThreads();
44918 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44919 wxPyEndAllowThreads(__tstate);
44920 if (PyErr_Occurred()) SWIG_fail;
44921 }
44922 resultobj = SWIG_From_int(static_cast< int >(result));
44923 {
44924 if (temp2)
44925 delete arg2;
44926 }
44927 return resultobj;
44928 fail:
44929 {
44930 if (temp2)
44931 delete arg2;
44932 }
44933 return NULL;
44934 }
44935
44936
44937 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44938 PyObject *resultobj = 0;
44939 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44940 wxArrayString *arg2 = 0 ;
44941 void *argp1 = 0 ;
44942 int res1 = 0 ;
44943 bool temp2 = false ;
44944 PyObject * obj0 = 0 ;
44945 PyObject * obj1 = 0 ;
44946 char * kwnames[] = {
44947 (char *) "self",(char *) "strings", NULL
44948 };
44949
44950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44952 if (!SWIG_IsOK(res1)) {
44953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44954 }
44955 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44956 {
44957 if (! PySequence_Check(obj1)) {
44958 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44959 SWIG_fail;
44960 }
44961 arg2 = new wxArrayString;
44962 temp2 = true;
44963 int i, len=PySequence_Length(obj1);
44964 for (i=0; i<len; i++) {
44965 PyObject* item = PySequence_GetItem(obj1, i);
44966 wxString* s = wxString_in_helper(item);
44967 if (PyErr_Occurred()) SWIG_fail;
44968 arg2->Add(*s);
44969 delete s;
44970 Py_DECREF(item);
44971 }
44972 }
44973 {
44974 PyThreadState* __tstate = wxPyBeginAllowThreads();
44975 (arg1)->Append((wxArrayString const &)*arg2);
44976 wxPyEndAllowThreads(__tstate);
44977 if (PyErr_Occurred()) SWIG_fail;
44978 }
44979 resultobj = SWIG_Py_Void();
44980 {
44981 if (temp2) delete arg2;
44982 }
44983 return resultobj;
44984 fail:
44985 {
44986 if (temp2) delete arg2;
44987 }
44988 return NULL;
44989 }
44990
44991
44992 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj = 0;
44994 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44995 wxString *arg2 = 0 ;
44996 unsigned int arg3 ;
44997 PyObject *arg4 = (PyObject *) NULL ;
44998 int result;
44999 void *argp1 = 0 ;
45000 int res1 = 0 ;
45001 bool temp2 = false ;
45002 unsigned int val3 ;
45003 int ecode3 = 0 ;
45004 PyObject * obj0 = 0 ;
45005 PyObject * obj1 = 0 ;
45006 PyObject * obj2 = 0 ;
45007 PyObject * obj3 = 0 ;
45008 char * kwnames[] = {
45009 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45010 };
45011
45012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45014 if (!SWIG_IsOK(res1)) {
45015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45016 }
45017 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45018 {
45019 arg2 = wxString_in_helper(obj1);
45020 if (arg2 == NULL) SWIG_fail;
45021 temp2 = true;
45022 }
45023 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45024 if (!SWIG_IsOK(ecode3)) {
45025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45026 }
45027 arg3 = static_cast< unsigned int >(val3);
45028 if (obj3) {
45029 arg4 = obj3;
45030 }
45031 {
45032 PyThreadState* __tstate = wxPyBeginAllowThreads();
45033 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_From_int(static_cast< int >(result));
45038 {
45039 if (temp2)
45040 delete arg2;
45041 }
45042 return resultobj;
45043 fail:
45044 {
45045 if (temp2)
45046 delete arg2;
45047 }
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45053 PyObject *resultobj = 0;
45054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45055 void *argp1 = 0 ;
45056 int res1 = 0 ;
45057 PyObject *swig_obj[1] ;
45058
45059 if (!args) SWIG_fail;
45060 swig_obj[0] = args;
45061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45062 if (!SWIG_IsOK(res1)) {
45063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45064 }
45065 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45066 {
45067 PyThreadState* __tstate = wxPyBeginAllowThreads();
45068 (arg1)->Clear();
45069 wxPyEndAllowThreads(__tstate);
45070 if (PyErr_Occurred()) SWIG_fail;
45071 }
45072 resultobj = SWIG_Py_Void();
45073 return resultobj;
45074 fail:
45075 return NULL;
45076 }
45077
45078
45079 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45080 PyObject *resultobj = 0;
45081 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45082 unsigned int arg2 ;
45083 void *argp1 = 0 ;
45084 int res1 = 0 ;
45085 unsigned int val2 ;
45086 int ecode2 = 0 ;
45087 PyObject * obj0 = 0 ;
45088 PyObject * obj1 = 0 ;
45089 char * kwnames[] = {
45090 (char *) "self",(char *) "n", NULL
45091 };
45092
45093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45095 if (!SWIG_IsOK(res1)) {
45096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45097 }
45098 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45099 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45100 if (!SWIG_IsOK(ecode2)) {
45101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45102 }
45103 arg2 = static_cast< unsigned int >(val2);
45104 {
45105 PyThreadState* __tstate = wxPyBeginAllowThreads();
45106 (arg1)->Delete(arg2);
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 resultobj = SWIG_Py_Void();
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj = 0;
45119 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45120 unsigned int arg2 ;
45121 PyObject *result = 0 ;
45122 void *argp1 = 0 ;
45123 int res1 = 0 ;
45124 unsigned int val2 ;
45125 int ecode2 = 0 ;
45126 PyObject * obj0 = 0 ;
45127 PyObject * obj1 = 0 ;
45128 char * kwnames[] = {
45129 (char *) "self",(char *) "n", NULL
45130 };
45131
45132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45134 if (!SWIG_IsOK(res1)) {
45135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45136 }
45137 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45138 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45139 if (!SWIG_IsOK(ecode2)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45141 }
45142 arg2 = static_cast< unsigned int >(val2);
45143 {
45144 PyThreadState* __tstate = wxPyBeginAllowThreads();
45145 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45146 wxPyEndAllowThreads(__tstate);
45147 if (PyErr_Occurred()) SWIG_fail;
45148 }
45149 resultobj = result;
45150 return resultobj;
45151 fail:
45152 return NULL;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45159 unsigned int arg2 ;
45160 PyObject *arg3 = (PyObject *) 0 ;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 unsigned int val2 ;
45164 int ecode2 = 0 ;
45165 PyObject * obj0 = 0 ;
45166 PyObject * obj1 = 0 ;
45167 PyObject * obj2 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "n",(char *) "clientData", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45176 }
45177 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45178 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45179 if (!SWIG_IsOK(ecode2)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45181 }
45182 arg2 = static_cast< unsigned int >(val2);
45183 arg3 = obj2;
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 wxItemContainer_SetClientData(arg1,arg2,arg3);
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_Py_Void();
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45198 PyObject *resultobj = 0;
45199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45200 unsigned int result;
45201 void *argp1 = 0 ;
45202 int res1 = 0 ;
45203 PyObject *swig_obj[1] ;
45204
45205 if (!args) SWIG_fail;
45206 swig_obj[0] = args;
45207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45208 if (!SWIG_IsOK(res1)) {
45209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45210 }
45211 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45212 {
45213 PyThreadState* __tstate = wxPyBeginAllowThreads();
45214 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45215 wxPyEndAllowThreads(__tstate);
45216 if (PyErr_Occurred()) SWIG_fail;
45217 }
45218 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45219 return resultobj;
45220 fail:
45221 return NULL;
45222 }
45223
45224
45225 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45226 PyObject *resultobj = 0;
45227 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45228 bool result;
45229 void *argp1 = 0 ;
45230 int res1 = 0 ;
45231 PyObject *swig_obj[1] ;
45232
45233 if (!args) SWIG_fail;
45234 swig_obj[0] = args;
45235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45236 if (!SWIG_IsOK(res1)) {
45237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45238 }
45239 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45240 {
45241 PyThreadState* __tstate = wxPyBeginAllowThreads();
45242 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45243 wxPyEndAllowThreads(__tstate);
45244 if (PyErr_Occurred()) SWIG_fail;
45245 }
45246 {
45247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45248 }
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj = 0;
45257 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45258 unsigned int arg2 ;
45259 wxString result;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 unsigned int val2 ;
45263 int ecode2 = 0 ;
45264 PyObject * obj0 = 0 ;
45265 PyObject * obj1 = 0 ;
45266 char * kwnames[] = {
45267 (char *) "self",(char *) "n", NULL
45268 };
45269
45270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45274 }
45275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45276 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45277 if (!SWIG_IsOK(ecode2)) {
45278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45279 }
45280 arg2 = static_cast< unsigned int >(val2);
45281 {
45282 PyThreadState* __tstate = wxPyBeginAllowThreads();
45283 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45284 wxPyEndAllowThreads(__tstate);
45285 if (PyErr_Occurred()) SWIG_fail;
45286 }
45287 {
45288 #if wxUSE_UNICODE
45289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45290 #else
45291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45292 #endif
45293 }
45294 return resultobj;
45295 fail:
45296 return NULL;
45297 }
45298
45299
45300 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45301 PyObject *resultobj = 0;
45302 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45303 wxArrayString result;
45304 void *argp1 = 0 ;
45305 int res1 = 0 ;
45306 PyObject *swig_obj[1] ;
45307
45308 if (!args) SWIG_fail;
45309 swig_obj[0] = args;
45310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45311 if (!SWIG_IsOK(res1)) {
45312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45313 }
45314 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45315 {
45316 PyThreadState* __tstate = wxPyBeginAllowThreads();
45317 result = ((wxItemContainer const *)arg1)->GetStrings();
45318 wxPyEndAllowThreads(__tstate);
45319 if (PyErr_Occurred()) SWIG_fail;
45320 }
45321 {
45322 resultobj = wxArrayString2PyList_helper(result);
45323 }
45324 return resultobj;
45325 fail:
45326 return NULL;
45327 }
45328
45329
45330 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45331 PyObject *resultobj = 0;
45332 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45333 unsigned int arg2 ;
45334 wxString *arg3 = 0 ;
45335 void *argp1 = 0 ;
45336 int res1 = 0 ;
45337 unsigned int val2 ;
45338 int ecode2 = 0 ;
45339 bool temp3 = false ;
45340 PyObject * obj0 = 0 ;
45341 PyObject * obj1 = 0 ;
45342 PyObject * obj2 = 0 ;
45343 char * kwnames[] = {
45344 (char *) "self",(char *) "n",(char *) "s", NULL
45345 };
45346
45347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45351 }
45352 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45353 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45354 if (!SWIG_IsOK(ecode2)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45356 }
45357 arg2 = static_cast< unsigned int >(val2);
45358 {
45359 arg3 = wxString_in_helper(obj2);
45360 if (arg3 == NULL) SWIG_fail;
45361 temp3 = true;
45362 }
45363 {
45364 PyThreadState* __tstate = wxPyBeginAllowThreads();
45365 (arg1)->SetString(arg2,(wxString const &)*arg3);
45366 wxPyEndAllowThreads(__tstate);
45367 if (PyErr_Occurred()) SWIG_fail;
45368 }
45369 resultobj = SWIG_Py_Void();
45370 {
45371 if (temp3)
45372 delete arg3;
45373 }
45374 return resultobj;
45375 fail:
45376 {
45377 if (temp3)
45378 delete arg3;
45379 }
45380 return NULL;
45381 }
45382
45383
45384 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45385 PyObject *resultobj = 0;
45386 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45387 wxString *arg2 = 0 ;
45388 int result;
45389 void *argp1 = 0 ;
45390 int res1 = 0 ;
45391 bool temp2 = false ;
45392 PyObject * obj0 = 0 ;
45393 PyObject * obj1 = 0 ;
45394 char * kwnames[] = {
45395 (char *) "self",(char *) "s", NULL
45396 };
45397
45398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45400 if (!SWIG_IsOK(res1)) {
45401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45402 }
45403 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45404 {
45405 arg2 = wxString_in_helper(obj1);
45406 if (arg2 == NULL) SWIG_fail;
45407 temp2 = true;
45408 }
45409 {
45410 PyThreadState* __tstate = wxPyBeginAllowThreads();
45411 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45412 wxPyEndAllowThreads(__tstate);
45413 if (PyErr_Occurred()) SWIG_fail;
45414 }
45415 resultobj = SWIG_From_int(static_cast< int >(result));
45416 {
45417 if (temp2)
45418 delete arg2;
45419 }
45420 return resultobj;
45421 fail:
45422 {
45423 if (temp2)
45424 delete arg2;
45425 }
45426 return NULL;
45427 }
45428
45429
45430 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45431 PyObject *resultobj = 0;
45432 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45433 int arg2 ;
45434 void *argp1 = 0 ;
45435 int res1 = 0 ;
45436 int val2 ;
45437 int ecode2 = 0 ;
45438 PyObject * obj0 = 0 ;
45439 PyObject * obj1 = 0 ;
45440 char * kwnames[] = {
45441 (char *) "self",(char *) "n", NULL
45442 };
45443
45444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45446 if (!SWIG_IsOK(res1)) {
45447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45448 }
45449 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45450 ecode2 = SWIG_AsVal_int(obj1, &val2);
45451 if (!SWIG_IsOK(ecode2)) {
45452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45453 }
45454 arg2 = static_cast< int >(val2);
45455 {
45456 PyThreadState* __tstate = wxPyBeginAllowThreads();
45457 (arg1)->SetSelection(arg2);
45458 wxPyEndAllowThreads(__tstate);
45459 if (PyErr_Occurred()) SWIG_fail;
45460 }
45461 resultobj = SWIG_Py_Void();
45462 return resultobj;
45463 fail:
45464 return NULL;
45465 }
45466
45467
45468 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45469 PyObject *resultobj = 0;
45470 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45471 int result;
45472 void *argp1 = 0 ;
45473 int res1 = 0 ;
45474 PyObject *swig_obj[1] ;
45475
45476 if (!args) SWIG_fail;
45477 swig_obj[0] = args;
45478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45479 if (!SWIG_IsOK(res1)) {
45480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45481 }
45482 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45483 {
45484 PyThreadState* __tstate = wxPyBeginAllowThreads();
45485 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45486 wxPyEndAllowThreads(__tstate);
45487 if (PyErr_Occurred()) SWIG_fail;
45488 }
45489 resultobj = SWIG_From_int(static_cast< int >(result));
45490 return resultobj;
45491 fail:
45492 return NULL;
45493 }
45494
45495
45496 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45497 PyObject *resultobj = 0;
45498 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45499 wxString *arg2 = 0 ;
45500 bool result;
45501 void *argp1 = 0 ;
45502 int res1 = 0 ;
45503 bool temp2 = false ;
45504 PyObject * obj0 = 0 ;
45505 PyObject * obj1 = 0 ;
45506 char * kwnames[] = {
45507 (char *) "self",(char *) "s", NULL
45508 };
45509
45510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45512 if (!SWIG_IsOK(res1)) {
45513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45514 }
45515 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45516 {
45517 arg2 = wxString_in_helper(obj1);
45518 if (arg2 == NULL) SWIG_fail;
45519 temp2 = true;
45520 }
45521 {
45522 PyThreadState* __tstate = wxPyBeginAllowThreads();
45523 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45524 wxPyEndAllowThreads(__tstate);
45525 if (PyErr_Occurred()) SWIG_fail;
45526 }
45527 {
45528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45529 }
45530 {
45531 if (temp2)
45532 delete arg2;
45533 }
45534 return resultobj;
45535 fail:
45536 {
45537 if (temp2)
45538 delete arg2;
45539 }
45540 return NULL;
45541 }
45542
45543
45544 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45545 PyObject *resultobj = 0;
45546 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45547 wxString result;
45548 void *argp1 = 0 ;
45549 int res1 = 0 ;
45550 PyObject *swig_obj[1] ;
45551
45552 if (!args) SWIG_fail;
45553 swig_obj[0] = args;
45554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45555 if (!SWIG_IsOK(res1)) {
45556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45557 }
45558 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45559 {
45560 PyThreadState* __tstate = wxPyBeginAllowThreads();
45561 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45562 wxPyEndAllowThreads(__tstate);
45563 if (PyErr_Occurred()) SWIG_fail;
45564 }
45565 {
45566 #if wxUSE_UNICODE
45567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45568 #else
45569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45570 #endif
45571 }
45572 return resultobj;
45573 fail:
45574 return NULL;
45575 }
45576
45577
45578 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45579 PyObject *resultobj = 0;
45580 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45581 int arg2 ;
45582 void *argp1 = 0 ;
45583 int res1 = 0 ;
45584 int val2 ;
45585 int ecode2 = 0 ;
45586 PyObject * obj0 = 0 ;
45587 PyObject * obj1 = 0 ;
45588 char * kwnames[] = {
45589 (char *) "self",(char *) "n", NULL
45590 };
45591
45592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45594 if (!SWIG_IsOK(res1)) {
45595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45596 }
45597 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45598 ecode2 = SWIG_AsVal_int(obj1, &val2);
45599 if (!SWIG_IsOK(ecode2)) {
45600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45601 }
45602 arg2 = static_cast< int >(val2);
45603 {
45604 PyThreadState* __tstate = wxPyBeginAllowThreads();
45605 (arg1)->Select(arg2);
45606 wxPyEndAllowThreads(__tstate);
45607 if (PyErr_Occurred()) SWIG_fail;
45608 }
45609 resultobj = SWIG_Py_Void();
45610 return resultobj;
45611 fail:
45612 return NULL;
45613 }
45614
45615
45616 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45617 PyObject *obj;
45618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45619 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45620 return SWIG_Py_Void();
45621 }
45622
45623 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45624 PyObject *obj;
45625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45626 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45627 return SWIG_Py_Void();
45628 }
45629
45630 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45631 PyObject *resultobj = 0;
45632 wxSizerItem *result = 0 ;
45633
45634 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45635 {
45636 PyThreadState* __tstate = wxPyBeginAllowThreads();
45637 result = (wxSizerItem *)new wxSizerItem();
45638 wxPyEndAllowThreads(__tstate);
45639 if (PyErr_Occurred()) SWIG_fail;
45640 }
45641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45642 return resultobj;
45643 fail:
45644 return NULL;
45645 }
45646
45647
45648 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45649 PyObject *resultobj = 0;
45650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45651 void *argp1 = 0 ;
45652 int res1 = 0 ;
45653 PyObject *swig_obj[1] ;
45654
45655 if (!args) SWIG_fail;
45656 swig_obj[0] = args;
45657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45658 if (!SWIG_IsOK(res1)) {
45659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45660 }
45661 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45662 {
45663 PyThreadState* __tstate = wxPyBeginAllowThreads();
45664 delete arg1;
45665
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_Py_Void();
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45677 PyObject *resultobj = 0;
45678 wxWindow *arg1 = (wxWindow *) 0 ;
45679 int arg2 ;
45680 int arg3 ;
45681 int arg4 ;
45682 PyObject *arg5 = (PyObject *) NULL ;
45683 wxSizerItem *result = 0 ;
45684 void *argp1 = 0 ;
45685 int res1 = 0 ;
45686 int val2 ;
45687 int ecode2 = 0 ;
45688 int val3 ;
45689 int ecode3 = 0 ;
45690 int val4 ;
45691 int ecode4 = 0 ;
45692 PyObject * obj0 = 0 ;
45693 PyObject * obj1 = 0 ;
45694 PyObject * obj2 = 0 ;
45695 PyObject * obj3 = 0 ;
45696 PyObject * obj4 = 0 ;
45697 char * kwnames[] = {
45698 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45699 };
45700
45701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45703 if (!SWIG_IsOK(res1)) {
45704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45705 }
45706 arg1 = reinterpret_cast< wxWindow * >(argp1);
45707 ecode2 = SWIG_AsVal_int(obj1, &val2);
45708 if (!SWIG_IsOK(ecode2)) {
45709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45710 }
45711 arg2 = static_cast< int >(val2);
45712 ecode3 = SWIG_AsVal_int(obj2, &val3);
45713 if (!SWIG_IsOK(ecode3)) {
45714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45715 }
45716 arg3 = static_cast< int >(val3);
45717 ecode4 = SWIG_AsVal_int(obj3, &val4);
45718 if (!SWIG_IsOK(ecode4)) {
45719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45720 }
45721 arg4 = static_cast< int >(val4);
45722 if (obj4) {
45723 arg5 = obj4;
45724 }
45725 {
45726 PyThreadState* __tstate = wxPyBeginAllowThreads();
45727 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45728 wxPyEndAllowThreads(__tstate);
45729 if (PyErr_Occurred()) SWIG_fail;
45730 }
45731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45732 return resultobj;
45733 fail:
45734 return NULL;
45735 }
45736
45737
45738 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45739 PyObject *resultobj = 0;
45740 int arg1 ;
45741 int arg2 ;
45742 int arg3 ;
45743 int arg4 ;
45744 int arg5 ;
45745 PyObject *arg6 = (PyObject *) NULL ;
45746 wxSizerItem *result = 0 ;
45747 int val1 ;
45748 int ecode1 = 0 ;
45749 int val2 ;
45750 int ecode2 = 0 ;
45751 int val3 ;
45752 int ecode3 = 0 ;
45753 int val4 ;
45754 int ecode4 = 0 ;
45755 int val5 ;
45756 int ecode5 = 0 ;
45757 PyObject * obj0 = 0 ;
45758 PyObject * obj1 = 0 ;
45759 PyObject * obj2 = 0 ;
45760 PyObject * obj3 = 0 ;
45761 PyObject * obj4 = 0 ;
45762 PyObject * obj5 = 0 ;
45763 char * kwnames[] = {
45764 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45765 };
45766
45767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45768 ecode1 = SWIG_AsVal_int(obj0, &val1);
45769 if (!SWIG_IsOK(ecode1)) {
45770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45771 }
45772 arg1 = static_cast< int >(val1);
45773 ecode2 = SWIG_AsVal_int(obj1, &val2);
45774 if (!SWIG_IsOK(ecode2)) {
45775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45776 }
45777 arg2 = static_cast< int >(val2);
45778 ecode3 = SWIG_AsVal_int(obj2, &val3);
45779 if (!SWIG_IsOK(ecode3)) {
45780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45781 }
45782 arg3 = static_cast< int >(val3);
45783 ecode4 = SWIG_AsVal_int(obj3, &val4);
45784 if (!SWIG_IsOK(ecode4)) {
45785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45786 }
45787 arg4 = static_cast< int >(val4);
45788 ecode5 = SWIG_AsVal_int(obj4, &val5);
45789 if (!SWIG_IsOK(ecode5)) {
45790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45791 }
45792 arg5 = static_cast< int >(val5);
45793 if (obj5) {
45794 arg6 = obj5;
45795 }
45796 {
45797 PyThreadState* __tstate = wxPyBeginAllowThreads();
45798 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45799 wxPyEndAllowThreads(__tstate);
45800 if (PyErr_Occurred()) SWIG_fail;
45801 }
45802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45803 return resultobj;
45804 fail:
45805 return NULL;
45806 }
45807
45808
45809 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45810 PyObject *resultobj = 0;
45811 wxSizer *arg1 = (wxSizer *) 0 ;
45812 int arg2 ;
45813 int arg3 ;
45814 int arg4 ;
45815 PyObject *arg5 = (PyObject *) NULL ;
45816 wxSizerItem *result = 0 ;
45817 int res1 = 0 ;
45818 int val2 ;
45819 int ecode2 = 0 ;
45820 int val3 ;
45821 int ecode3 = 0 ;
45822 int val4 ;
45823 int ecode4 = 0 ;
45824 PyObject * obj0 = 0 ;
45825 PyObject * obj1 = 0 ;
45826 PyObject * obj2 = 0 ;
45827 PyObject * obj3 = 0 ;
45828 PyObject * obj4 = 0 ;
45829 char * kwnames[] = {
45830 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45831 };
45832
45833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45834 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45837 }
45838 ecode2 = SWIG_AsVal_int(obj1, &val2);
45839 if (!SWIG_IsOK(ecode2)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45841 }
45842 arg2 = static_cast< int >(val2);
45843 ecode3 = SWIG_AsVal_int(obj2, &val3);
45844 if (!SWIG_IsOK(ecode3)) {
45845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45846 }
45847 arg3 = static_cast< int >(val3);
45848 ecode4 = SWIG_AsVal_int(obj3, &val4);
45849 if (!SWIG_IsOK(ecode4)) {
45850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45851 }
45852 arg4 = static_cast< int >(val4);
45853 if (obj4) {
45854 arg5 = obj4;
45855 }
45856 {
45857 PyThreadState* __tstate = wxPyBeginAllowThreads();
45858 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45859 wxPyEndAllowThreads(__tstate);
45860 if (PyErr_Occurred()) SWIG_fail;
45861 }
45862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45863 return resultobj;
45864 fail:
45865 return NULL;
45866 }
45867
45868
45869 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45870 PyObject *resultobj = 0;
45871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45872 void *argp1 = 0 ;
45873 int res1 = 0 ;
45874 PyObject *swig_obj[1] ;
45875
45876 if (!args) SWIG_fail;
45877 swig_obj[0] = args;
45878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45881 }
45882 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 (arg1)->DeleteWindows();
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 resultobj = SWIG_Py_Void();
45890 return resultobj;
45891 fail:
45892 return NULL;
45893 }
45894
45895
45896 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45897 PyObject *resultobj = 0;
45898 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45899 void *argp1 = 0 ;
45900 int res1 = 0 ;
45901 PyObject *swig_obj[1] ;
45902
45903 if (!args) SWIG_fail;
45904 swig_obj[0] = args;
45905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45906 if (!SWIG_IsOK(res1)) {
45907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45908 }
45909 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 (arg1)->DetachSizer();
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 resultobj = SWIG_Py_Void();
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45924 PyObject *resultobj = 0;
45925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45926 wxSize result;
45927 void *argp1 = 0 ;
45928 int res1 = 0 ;
45929 PyObject *swig_obj[1] ;
45930
45931 if (!args) SWIG_fail;
45932 swig_obj[0] = args;
45933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45934 if (!SWIG_IsOK(res1)) {
45935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45936 }
45937 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 result = (arg1)->GetSize();
45941 wxPyEndAllowThreads(__tstate);
45942 if (PyErr_Occurred()) SWIG_fail;
45943 }
45944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45952 PyObject *resultobj = 0;
45953 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45954 wxSize result;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 PyObject *swig_obj[1] ;
45958
45959 if (!args) SWIG_fail;
45960 swig_obj[0] = args;
45961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45962 if (!SWIG_IsOK(res1)) {
45963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45964 }
45965 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45966 {
45967 PyThreadState* __tstate = wxPyBeginAllowThreads();
45968 result = (arg1)->CalcMin();
45969 wxPyEndAllowThreads(__tstate);
45970 if (PyErr_Occurred()) SWIG_fail;
45971 }
45972 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45980 PyObject *resultobj = 0;
45981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45982 wxPoint *arg2 = 0 ;
45983 wxSize *arg3 = 0 ;
45984 void *argp1 = 0 ;
45985 int res1 = 0 ;
45986 wxPoint temp2 ;
45987 wxSize temp3 ;
45988 PyObject * obj0 = 0 ;
45989 PyObject * obj1 = 0 ;
45990 PyObject * obj2 = 0 ;
45991 char * kwnames[] = {
45992 (char *) "self",(char *) "pos",(char *) "size", NULL
45993 };
45994
45995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45997 if (!SWIG_IsOK(res1)) {
45998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45999 }
46000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46001 {
46002 arg2 = &temp2;
46003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46004 }
46005 {
46006 arg3 = &temp3;
46007 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46008 }
46009 {
46010 PyThreadState* __tstate = wxPyBeginAllowThreads();
46011 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46012 wxPyEndAllowThreads(__tstate);
46013 if (PyErr_Occurred()) SWIG_fail;
46014 }
46015 resultobj = SWIG_Py_Void();
46016 return resultobj;
46017 fail:
46018 return NULL;
46019 }
46020
46021
46022 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46023 PyObject *resultobj = 0;
46024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46025 wxSize result;
46026 void *argp1 = 0 ;
46027 int res1 = 0 ;
46028 PyObject *swig_obj[1] ;
46029
46030 if (!args) SWIG_fail;
46031 swig_obj[0] = args;
46032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46033 if (!SWIG_IsOK(res1)) {
46034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46035 }
46036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46037 {
46038 PyThreadState* __tstate = wxPyBeginAllowThreads();
46039 result = (arg1)->GetMinSize();
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46044 return resultobj;
46045 fail:
46046 return NULL;
46047 }
46048
46049
46050 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46051 PyObject *resultobj = 0;
46052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46053 wxSize result;
46054 void *argp1 = 0 ;
46055 int res1 = 0 ;
46056 PyObject *swig_obj[1] ;
46057
46058 if (!args) SWIG_fail;
46059 swig_obj[0] = args;
46060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46061 if (!SWIG_IsOK(res1)) {
46062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46063 }
46064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46065 {
46066 PyThreadState* __tstate = wxPyBeginAllowThreads();
46067 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46068 wxPyEndAllowThreads(__tstate);
46069 if (PyErr_Occurred()) SWIG_fail;
46070 }
46071 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46072 return resultobj;
46073 fail:
46074 return NULL;
46075 }
46076
46077
46078 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46079 PyObject *resultobj = 0;
46080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46081 int arg2 ;
46082 int arg3 ;
46083 void *argp1 = 0 ;
46084 int res1 = 0 ;
46085 int val2 ;
46086 int ecode2 = 0 ;
46087 int val3 ;
46088 int ecode3 = 0 ;
46089 PyObject * obj0 = 0 ;
46090 PyObject * obj1 = 0 ;
46091 PyObject * obj2 = 0 ;
46092 char * kwnames[] = {
46093 (char *) "self",(char *) "x",(char *) "y", NULL
46094 };
46095
46096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46098 if (!SWIG_IsOK(res1)) {
46099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46100 }
46101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46102 ecode2 = SWIG_AsVal_int(obj1, &val2);
46103 if (!SWIG_IsOK(ecode2)) {
46104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46105 }
46106 arg2 = static_cast< int >(val2);
46107 ecode3 = SWIG_AsVal_int(obj2, &val3);
46108 if (!SWIG_IsOK(ecode3)) {
46109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46110 }
46111 arg3 = static_cast< int >(val3);
46112 {
46113 PyThreadState* __tstate = wxPyBeginAllowThreads();
46114 (arg1)->SetInitSize(arg2,arg3);
46115 wxPyEndAllowThreads(__tstate);
46116 if (PyErr_Occurred()) SWIG_fail;
46117 }
46118 resultobj = SWIG_Py_Void();
46119 return resultobj;
46120 fail:
46121 return NULL;
46122 }
46123
46124
46125 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46126 PyObject *resultobj = 0;
46127 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46128 int arg2 ;
46129 int arg3 ;
46130 void *argp1 = 0 ;
46131 int res1 = 0 ;
46132 int val2 ;
46133 int ecode2 = 0 ;
46134 int val3 ;
46135 int ecode3 = 0 ;
46136 PyObject * obj0 = 0 ;
46137 PyObject * obj1 = 0 ;
46138 PyObject * obj2 = 0 ;
46139 char * kwnames[] = {
46140 (char *) "self",(char *) "width",(char *) "height", NULL
46141 };
46142
46143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46145 if (!SWIG_IsOK(res1)) {
46146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46147 }
46148 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46149 ecode2 = SWIG_AsVal_int(obj1, &val2);
46150 if (!SWIG_IsOK(ecode2)) {
46151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46152 }
46153 arg2 = static_cast< int >(val2);
46154 ecode3 = SWIG_AsVal_int(obj2, &val3);
46155 if (!SWIG_IsOK(ecode3)) {
46156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46157 }
46158 arg3 = static_cast< int >(val3);
46159 {
46160 PyThreadState* __tstate = wxPyBeginAllowThreads();
46161 (arg1)->SetRatio(arg2,arg3);
46162 wxPyEndAllowThreads(__tstate);
46163 if (PyErr_Occurred()) SWIG_fail;
46164 }
46165 resultobj = SWIG_Py_Void();
46166 return resultobj;
46167 fail:
46168 return NULL;
46169 }
46170
46171
46172 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46173 PyObject *resultobj = 0;
46174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46175 wxSize *arg2 = 0 ;
46176 void *argp1 = 0 ;
46177 int res1 = 0 ;
46178 wxSize temp2 ;
46179 PyObject * obj0 = 0 ;
46180 PyObject * obj1 = 0 ;
46181 char * kwnames[] = {
46182 (char *) "self",(char *) "size", NULL
46183 };
46184
46185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46187 if (!SWIG_IsOK(res1)) {
46188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46189 }
46190 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46191 {
46192 arg2 = &temp2;
46193 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46194 }
46195 {
46196 PyThreadState* __tstate = wxPyBeginAllowThreads();
46197 (arg1)->SetRatio((wxSize const &)*arg2);
46198 wxPyEndAllowThreads(__tstate);
46199 if (PyErr_Occurred()) SWIG_fail;
46200 }
46201 resultobj = SWIG_Py_Void();
46202 return resultobj;
46203 fail:
46204 return NULL;
46205 }
46206
46207
46208 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46209 PyObject *resultobj = 0;
46210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46211 float arg2 ;
46212 void *argp1 = 0 ;
46213 int res1 = 0 ;
46214 float val2 ;
46215 int ecode2 = 0 ;
46216 PyObject * obj0 = 0 ;
46217 PyObject * obj1 = 0 ;
46218 char * kwnames[] = {
46219 (char *) "self",(char *) "ratio", NULL
46220 };
46221
46222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46224 if (!SWIG_IsOK(res1)) {
46225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46226 }
46227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46228 ecode2 = SWIG_AsVal_float(obj1, &val2);
46229 if (!SWIG_IsOK(ecode2)) {
46230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46231 }
46232 arg2 = static_cast< float >(val2);
46233 {
46234 PyThreadState* __tstate = wxPyBeginAllowThreads();
46235 (arg1)->SetRatio(arg2);
46236 wxPyEndAllowThreads(__tstate);
46237 if (PyErr_Occurred()) SWIG_fail;
46238 }
46239 resultobj = SWIG_Py_Void();
46240 return resultobj;
46241 fail:
46242 return NULL;
46243 }
46244
46245
46246 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46247 PyObject *resultobj = 0;
46248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46249 float result;
46250 void *argp1 = 0 ;
46251 int res1 = 0 ;
46252 PyObject *swig_obj[1] ;
46253
46254 if (!args) SWIG_fail;
46255 swig_obj[0] = args;
46256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46257 if (!SWIG_IsOK(res1)) {
46258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46259 }
46260 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46261 {
46262 PyThreadState* __tstate = wxPyBeginAllowThreads();
46263 result = (float)(arg1)->GetRatio();
46264 wxPyEndAllowThreads(__tstate);
46265 if (PyErr_Occurred()) SWIG_fail;
46266 }
46267 resultobj = SWIG_From_float(static_cast< float >(result));
46268 return resultobj;
46269 fail:
46270 return NULL;
46271 }
46272
46273
46274 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46275 PyObject *resultobj = 0;
46276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46277 wxRect result;
46278 void *argp1 = 0 ;
46279 int res1 = 0 ;
46280 PyObject *swig_obj[1] ;
46281
46282 if (!args) SWIG_fail;
46283 swig_obj[0] = args;
46284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46285 if (!SWIG_IsOK(res1)) {
46286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46287 }
46288 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 result = (arg1)->GetRect();
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46303 PyObject *resultobj = 0;
46304 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46305 bool result;
46306 void *argp1 = 0 ;
46307 int res1 = 0 ;
46308 PyObject *swig_obj[1] ;
46309
46310 if (!args) SWIG_fail;
46311 swig_obj[0] = args;
46312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46313 if (!SWIG_IsOK(res1)) {
46314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46315 }
46316 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 result = (bool)(arg1)->IsWindow();
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 {
46324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46325 }
46326 return resultobj;
46327 fail:
46328 return NULL;
46329 }
46330
46331
46332 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46333 PyObject *resultobj = 0;
46334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46335 bool result;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 PyObject *swig_obj[1] ;
46339
46340 if (!args) SWIG_fail;
46341 swig_obj[0] = args;
46342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46343 if (!SWIG_IsOK(res1)) {
46344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46345 }
46346 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 result = (bool)(arg1)->IsSizer();
46350 wxPyEndAllowThreads(__tstate);
46351 if (PyErr_Occurred()) SWIG_fail;
46352 }
46353 {
46354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46355 }
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46363 PyObject *resultobj = 0;
46364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46365 bool result;
46366 void *argp1 = 0 ;
46367 int res1 = 0 ;
46368 PyObject *swig_obj[1] ;
46369
46370 if (!args) SWIG_fail;
46371 swig_obj[0] = args;
46372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46373 if (!SWIG_IsOK(res1)) {
46374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46375 }
46376 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46377 {
46378 PyThreadState* __tstate = wxPyBeginAllowThreads();
46379 result = (bool)(arg1)->IsSpacer();
46380 wxPyEndAllowThreads(__tstate);
46381 if (PyErr_Occurred()) SWIG_fail;
46382 }
46383 {
46384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46385 }
46386 return resultobj;
46387 fail:
46388 return NULL;
46389 }
46390
46391
46392 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46393 PyObject *resultobj = 0;
46394 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46395 int arg2 ;
46396 void *argp1 = 0 ;
46397 int res1 = 0 ;
46398 int val2 ;
46399 int ecode2 = 0 ;
46400 PyObject * obj0 = 0 ;
46401 PyObject * obj1 = 0 ;
46402 char * kwnames[] = {
46403 (char *) "self",(char *) "proportion", NULL
46404 };
46405
46406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46408 if (!SWIG_IsOK(res1)) {
46409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46410 }
46411 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46412 ecode2 = SWIG_AsVal_int(obj1, &val2);
46413 if (!SWIG_IsOK(ecode2)) {
46414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46415 }
46416 arg2 = static_cast< int >(val2);
46417 {
46418 PyThreadState* __tstate = wxPyBeginAllowThreads();
46419 (arg1)->SetProportion(arg2);
46420 wxPyEndAllowThreads(__tstate);
46421 if (PyErr_Occurred()) SWIG_fail;
46422 }
46423 resultobj = SWIG_Py_Void();
46424 return resultobj;
46425 fail:
46426 return NULL;
46427 }
46428
46429
46430 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46431 PyObject *resultobj = 0;
46432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46433 int result;
46434 void *argp1 = 0 ;
46435 int res1 = 0 ;
46436 PyObject *swig_obj[1] ;
46437
46438 if (!args) SWIG_fail;
46439 swig_obj[0] = args;
46440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46441 if (!SWIG_IsOK(res1)) {
46442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46443 }
46444 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46445 {
46446 PyThreadState* __tstate = wxPyBeginAllowThreads();
46447 result = (int)(arg1)->GetProportion();
46448 wxPyEndAllowThreads(__tstate);
46449 if (PyErr_Occurred()) SWIG_fail;
46450 }
46451 resultobj = SWIG_From_int(static_cast< int >(result));
46452 return resultobj;
46453 fail:
46454 return NULL;
46455 }
46456
46457
46458 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46459 PyObject *resultobj = 0;
46460 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46461 int arg2 ;
46462 void *argp1 = 0 ;
46463 int res1 = 0 ;
46464 int val2 ;
46465 int ecode2 = 0 ;
46466 PyObject * obj0 = 0 ;
46467 PyObject * obj1 = 0 ;
46468 char * kwnames[] = {
46469 (char *) "self",(char *) "flag", NULL
46470 };
46471
46472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46474 if (!SWIG_IsOK(res1)) {
46475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46476 }
46477 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46478 ecode2 = SWIG_AsVal_int(obj1, &val2);
46479 if (!SWIG_IsOK(ecode2)) {
46480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46481 }
46482 arg2 = static_cast< int >(val2);
46483 {
46484 PyThreadState* __tstate = wxPyBeginAllowThreads();
46485 (arg1)->SetFlag(arg2);
46486 wxPyEndAllowThreads(__tstate);
46487 if (PyErr_Occurred()) SWIG_fail;
46488 }
46489 resultobj = SWIG_Py_Void();
46490 return resultobj;
46491 fail:
46492 return NULL;
46493 }
46494
46495
46496 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46497 PyObject *resultobj = 0;
46498 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46499 int result;
46500 void *argp1 = 0 ;
46501 int res1 = 0 ;
46502 PyObject *swig_obj[1] ;
46503
46504 if (!args) SWIG_fail;
46505 swig_obj[0] = args;
46506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46507 if (!SWIG_IsOK(res1)) {
46508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46509 }
46510 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46511 {
46512 PyThreadState* __tstate = wxPyBeginAllowThreads();
46513 result = (int)(arg1)->GetFlag();
46514 wxPyEndAllowThreads(__tstate);
46515 if (PyErr_Occurred()) SWIG_fail;
46516 }
46517 resultobj = SWIG_From_int(static_cast< int >(result));
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46525 PyObject *resultobj = 0;
46526 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46527 int arg2 ;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 int val2 ;
46531 int ecode2 = 0 ;
46532 PyObject * obj0 = 0 ;
46533 PyObject * obj1 = 0 ;
46534 char * kwnames[] = {
46535 (char *) "self",(char *) "border", NULL
46536 };
46537
46538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46540 if (!SWIG_IsOK(res1)) {
46541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46542 }
46543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46544 ecode2 = SWIG_AsVal_int(obj1, &val2);
46545 if (!SWIG_IsOK(ecode2)) {
46546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46547 }
46548 arg2 = static_cast< int >(val2);
46549 {
46550 PyThreadState* __tstate = wxPyBeginAllowThreads();
46551 (arg1)->SetBorder(arg2);
46552 wxPyEndAllowThreads(__tstate);
46553 if (PyErr_Occurred()) SWIG_fail;
46554 }
46555 resultobj = SWIG_Py_Void();
46556 return resultobj;
46557 fail:
46558 return NULL;
46559 }
46560
46561
46562 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46563 PyObject *resultobj = 0;
46564 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46565 int result;
46566 void *argp1 = 0 ;
46567 int res1 = 0 ;
46568 PyObject *swig_obj[1] ;
46569
46570 if (!args) SWIG_fail;
46571 swig_obj[0] = args;
46572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46573 if (!SWIG_IsOK(res1)) {
46574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46575 }
46576 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 result = (int)(arg1)->GetBorder();
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_From_int(static_cast< int >(result));
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46591 PyObject *resultobj = 0;
46592 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46593 wxWindow *result = 0 ;
46594 void *argp1 = 0 ;
46595 int res1 = 0 ;
46596 PyObject *swig_obj[1] ;
46597
46598 if (!args) SWIG_fail;
46599 swig_obj[0] = args;
46600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46601 if (!SWIG_IsOK(res1)) {
46602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46603 }
46604 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46605 {
46606 PyThreadState* __tstate = wxPyBeginAllowThreads();
46607 result = (wxWindow *)(arg1)->GetWindow();
46608 wxPyEndAllowThreads(__tstate);
46609 if (PyErr_Occurred()) SWIG_fail;
46610 }
46611 {
46612 resultobj = wxPyMake_wxObject(result, 0);
46613 }
46614 return resultobj;
46615 fail:
46616 return NULL;
46617 }
46618
46619
46620 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46621 PyObject *resultobj = 0;
46622 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46623 wxWindow *arg2 = (wxWindow *) 0 ;
46624 void *argp1 = 0 ;
46625 int res1 = 0 ;
46626 void *argp2 = 0 ;
46627 int res2 = 0 ;
46628 PyObject * obj0 = 0 ;
46629 PyObject * obj1 = 0 ;
46630 char * kwnames[] = {
46631 (char *) "self",(char *) "window", NULL
46632 };
46633
46634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46636 if (!SWIG_IsOK(res1)) {
46637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46638 }
46639 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46641 if (!SWIG_IsOK(res2)) {
46642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46643 }
46644 arg2 = reinterpret_cast< wxWindow * >(argp2);
46645 {
46646 PyThreadState* __tstate = wxPyBeginAllowThreads();
46647 (arg1)->SetWindow(arg2);
46648 wxPyEndAllowThreads(__tstate);
46649 if (PyErr_Occurred()) SWIG_fail;
46650 }
46651 resultobj = SWIG_Py_Void();
46652 return resultobj;
46653 fail:
46654 return NULL;
46655 }
46656
46657
46658 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46659 PyObject *resultobj = 0;
46660 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46661 wxSizer *result = 0 ;
46662 void *argp1 = 0 ;
46663 int res1 = 0 ;
46664 PyObject *swig_obj[1] ;
46665
46666 if (!args) SWIG_fail;
46667 swig_obj[0] = args;
46668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46669 if (!SWIG_IsOK(res1)) {
46670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46671 }
46672 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46673 {
46674 PyThreadState* __tstate = wxPyBeginAllowThreads();
46675 result = (wxSizer *)(arg1)->GetSizer();
46676 wxPyEndAllowThreads(__tstate);
46677 if (PyErr_Occurred()) SWIG_fail;
46678 }
46679 {
46680 resultobj = wxPyMake_wxObject(result, (bool)0);
46681 }
46682 return resultobj;
46683 fail:
46684 return NULL;
46685 }
46686
46687
46688 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46689 PyObject *resultobj = 0;
46690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46691 wxSizer *arg2 = (wxSizer *) 0 ;
46692 void *argp1 = 0 ;
46693 int res1 = 0 ;
46694 int res2 = 0 ;
46695 PyObject * obj0 = 0 ;
46696 PyObject * obj1 = 0 ;
46697 char * kwnames[] = {
46698 (char *) "self",(char *) "sizer", NULL
46699 };
46700
46701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46703 if (!SWIG_IsOK(res1)) {
46704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46705 }
46706 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46707 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46708 if (!SWIG_IsOK(res2)) {
46709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46710 }
46711 {
46712 PyThreadState* __tstate = wxPyBeginAllowThreads();
46713 (arg1)->SetSizer(arg2);
46714 wxPyEndAllowThreads(__tstate);
46715 if (PyErr_Occurred()) SWIG_fail;
46716 }
46717 resultobj = SWIG_Py_Void();
46718 return resultobj;
46719 fail:
46720 return NULL;
46721 }
46722
46723
46724 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46725 PyObject *resultobj = 0;
46726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46727 wxSize *result = 0 ;
46728 void *argp1 = 0 ;
46729 int res1 = 0 ;
46730 PyObject *swig_obj[1] ;
46731
46732 if (!args) SWIG_fail;
46733 swig_obj[0] = args;
46734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46735 if (!SWIG_IsOK(res1)) {
46736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46737 }
46738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46739 {
46740 PyThreadState* __tstate = wxPyBeginAllowThreads();
46741 {
46742 wxSize const &_result_ref = (arg1)->GetSpacer();
46743 result = (wxSize *) &_result_ref;
46744 }
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46756 PyObject *resultobj = 0;
46757 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46758 wxSize *arg2 = 0 ;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 wxSize temp2 ;
46762 PyObject * obj0 = 0 ;
46763 PyObject * obj1 = 0 ;
46764 char * kwnames[] = {
46765 (char *) "self",(char *) "size", NULL
46766 };
46767
46768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46770 if (!SWIG_IsOK(res1)) {
46771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46772 }
46773 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46774 {
46775 arg2 = &temp2;
46776 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46777 }
46778 {
46779 PyThreadState* __tstate = wxPyBeginAllowThreads();
46780 (arg1)->SetSpacer((wxSize const &)*arg2);
46781 wxPyEndAllowThreads(__tstate);
46782 if (PyErr_Occurred()) SWIG_fail;
46783 }
46784 resultobj = SWIG_Py_Void();
46785 return resultobj;
46786 fail:
46787 return NULL;
46788 }
46789
46790
46791 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46792 PyObject *resultobj = 0;
46793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46794 bool arg2 ;
46795 void *argp1 = 0 ;
46796 int res1 = 0 ;
46797 bool val2 ;
46798 int ecode2 = 0 ;
46799 PyObject * obj0 = 0 ;
46800 PyObject * obj1 = 0 ;
46801 char * kwnames[] = {
46802 (char *) "self",(char *) "show", NULL
46803 };
46804
46805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46809 }
46810 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46811 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46812 if (!SWIG_IsOK(ecode2)) {
46813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46814 }
46815 arg2 = static_cast< bool >(val2);
46816 {
46817 PyThreadState* __tstate = wxPyBeginAllowThreads();
46818 (arg1)->Show(arg2);
46819 wxPyEndAllowThreads(__tstate);
46820 if (PyErr_Occurred()) SWIG_fail;
46821 }
46822 resultobj = SWIG_Py_Void();
46823 return resultobj;
46824 fail:
46825 return NULL;
46826 }
46827
46828
46829 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46830 PyObject *resultobj = 0;
46831 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46832 bool result;
46833 void *argp1 = 0 ;
46834 int res1 = 0 ;
46835 PyObject *swig_obj[1] ;
46836
46837 if (!args) SWIG_fail;
46838 swig_obj[0] = args;
46839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46840 if (!SWIG_IsOK(res1)) {
46841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46842 }
46843 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 result = (bool)(arg1)->IsShown();
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 {
46851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46852 }
46853 return resultobj;
46854 fail:
46855 return NULL;
46856 }
46857
46858
46859 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46860 PyObject *resultobj = 0;
46861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46862 wxPoint result;
46863 void *argp1 = 0 ;
46864 int res1 = 0 ;
46865 PyObject *swig_obj[1] ;
46866
46867 if (!args) SWIG_fail;
46868 swig_obj[0] = args;
46869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46870 if (!SWIG_IsOK(res1)) {
46871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46872 }
46873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46874 {
46875 PyThreadState* __tstate = wxPyBeginAllowThreads();
46876 result = (arg1)->GetPosition();
46877 wxPyEndAllowThreads(__tstate);
46878 if (PyErr_Occurred()) SWIG_fail;
46879 }
46880 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46881 return resultobj;
46882 fail:
46883 return NULL;
46884 }
46885
46886
46887 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46888 PyObject *resultobj = 0;
46889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46890 PyObject *result = 0 ;
46891 void *argp1 = 0 ;
46892 int res1 = 0 ;
46893 PyObject *swig_obj[1] ;
46894
46895 if (!args) SWIG_fail;
46896 swig_obj[0] = args;
46897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46900 }
46901 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46905 wxPyEndAllowThreads(__tstate);
46906 if (PyErr_Occurred()) SWIG_fail;
46907 }
46908 resultobj = result;
46909 return resultobj;
46910 fail:
46911 return NULL;
46912 }
46913
46914
46915 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46916 PyObject *resultobj = 0;
46917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46918 PyObject *arg2 = (PyObject *) 0 ;
46919 void *argp1 = 0 ;
46920 int res1 = 0 ;
46921 PyObject * obj0 = 0 ;
46922 PyObject * obj1 = 0 ;
46923 char * kwnames[] = {
46924 (char *) "self",(char *) "userData", NULL
46925 };
46926
46927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46929 if (!SWIG_IsOK(res1)) {
46930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46931 }
46932 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46933 arg2 = obj1;
46934 {
46935 PyThreadState* __tstate = wxPyBeginAllowThreads();
46936 wxSizerItem_SetUserData(arg1,arg2);
46937 wxPyEndAllowThreads(__tstate);
46938 if (PyErr_Occurred()) SWIG_fail;
46939 }
46940 resultobj = SWIG_Py_Void();
46941 return resultobj;
46942 fail:
46943 return NULL;
46944 }
46945
46946
46947 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46948 PyObject *obj;
46949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46950 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46951 return SWIG_Py_Void();
46952 }
46953
46954 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46955 return SWIG_Python_InitShadowInstance(args);
46956 }
46957
46958 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46959 PyObject *resultobj = 0;
46960 wxSizer *arg1 = (wxSizer *) 0 ;
46961 void *argp1 = 0 ;
46962 int res1 = 0 ;
46963 PyObject *swig_obj[1] ;
46964
46965 if (!args) SWIG_fail;
46966 swig_obj[0] = args;
46967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46968 if (!SWIG_IsOK(res1)) {
46969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46970 }
46971 arg1 = reinterpret_cast< wxSizer * >(argp1);
46972 {
46973 PyThreadState* __tstate = wxPyBeginAllowThreads();
46974 delete arg1;
46975
46976 wxPyEndAllowThreads(__tstate);
46977 if (PyErr_Occurred()) SWIG_fail;
46978 }
46979 resultobj = SWIG_Py_Void();
46980 return resultobj;
46981 fail:
46982 return NULL;
46983 }
46984
46985
46986 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46987 PyObject *resultobj = 0;
46988 wxSizer *arg1 = (wxSizer *) 0 ;
46989 PyObject *arg2 = (PyObject *) 0 ;
46990 void *argp1 = 0 ;
46991 int res1 = 0 ;
46992 PyObject * obj0 = 0 ;
46993 PyObject * obj1 = 0 ;
46994 char * kwnames[] = {
46995 (char *) "self",(char *) "_self", NULL
46996 };
46997
46998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47000 if (!SWIG_IsOK(res1)) {
47001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47002 }
47003 arg1 = reinterpret_cast< wxSizer * >(argp1);
47004 arg2 = obj1;
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 wxSizer__setOORInfo(arg1,arg2);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_Py_Void();
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47019 PyObject *resultobj = 0;
47020 wxSizer *arg1 = (wxSizer *) 0 ;
47021 PyObject *arg2 = (PyObject *) 0 ;
47022 int arg3 = (int) 0 ;
47023 int arg4 = (int) 0 ;
47024 int arg5 = (int) 0 ;
47025 PyObject *arg6 = (PyObject *) NULL ;
47026 wxSizerItem *result = 0 ;
47027 void *argp1 = 0 ;
47028 int res1 = 0 ;
47029 int val3 ;
47030 int ecode3 = 0 ;
47031 int val4 ;
47032 int ecode4 = 0 ;
47033 int val5 ;
47034 int ecode5 = 0 ;
47035 PyObject * obj0 = 0 ;
47036 PyObject * obj1 = 0 ;
47037 PyObject * obj2 = 0 ;
47038 PyObject * obj3 = 0 ;
47039 PyObject * obj4 = 0 ;
47040 PyObject * obj5 = 0 ;
47041 char * kwnames[] = {
47042 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47043 };
47044
47045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47049 }
47050 arg1 = reinterpret_cast< wxSizer * >(argp1);
47051 arg2 = obj1;
47052 if (obj2) {
47053 ecode3 = SWIG_AsVal_int(obj2, &val3);
47054 if (!SWIG_IsOK(ecode3)) {
47055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47056 }
47057 arg3 = static_cast< int >(val3);
47058 }
47059 if (obj3) {
47060 ecode4 = SWIG_AsVal_int(obj3, &val4);
47061 if (!SWIG_IsOK(ecode4)) {
47062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47063 }
47064 arg4 = static_cast< int >(val4);
47065 }
47066 if (obj4) {
47067 ecode5 = SWIG_AsVal_int(obj4, &val5);
47068 if (!SWIG_IsOK(ecode5)) {
47069 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47070 }
47071 arg5 = static_cast< int >(val5);
47072 }
47073 if (obj5) {
47074 arg6 = obj5;
47075 }
47076 {
47077 PyThreadState* __tstate = wxPyBeginAllowThreads();
47078 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47079 wxPyEndAllowThreads(__tstate);
47080 if (PyErr_Occurred()) SWIG_fail;
47081 }
47082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47083 return resultobj;
47084 fail:
47085 return NULL;
47086 }
47087
47088
47089 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47090 PyObject *resultobj = 0;
47091 wxSizer *arg1 = (wxSizer *) 0 ;
47092 int arg2 ;
47093 PyObject *arg3 = (PyObject *) 0 ;
47094 int arg4 = (int) 0 ;
47095 int arg5 = (int) 0 ;
47096 int arg6 = (int) 0 ;
47097 PyObject *arg7 = (PyObject *) NULL ;
47098 wxSizerItem *result = 0 ;
47099 void *argp1 = 0 ;
47100 int res1 = 0 ;
47101 int val2 ;
47102 int ecode2 = 0 ;
47103 int val4 ;
47104 int ecode4 = 0 ;
47105 int val5 ;
47106 int ecode5 = 0 ;
47107 int val6 ;
47108 int ecode6 = 0 ;
47109 PyObject * obj0 = 0 ;
47110 PyObject * obj1 = 0 ;
47111 PyObject * obj2 = 0 ;
47112 PyObject * obj3 = 0 ;
47113 PyObject * obj4 = 0 ;
47114 PyObject * obj5 = 0 ;
47115 PyObject * obj6 = 0 ;
47116 char * kwnames[] = {
47117 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47118 };
47119
47120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47122 if (!SWIG_IsOK(res1)) {
47123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47124 }
47125 arg1 = reinterpret_cast< wxSizer * >(argp1);
47126 ecode2 = SWIG_AsVal_int(obj1, &val2);
47127 if (!SWIG_IsOK(ecode2)) {
47128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47129 }
47130 arg2 = static_cast< int >(val2);
47131 arg3 = obj2;
47132 if (obj3) {
47133 ecode4 = SWIG_AsVal_int(obj3, &val4);
47134 if (!SWIG_IsOK(ecode4)) {
47135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47136 }
47137 arg4 = static_cast< int >(val4);
47138 }
47139 if (obj4) {
47140 ecode5 = SWIG_AsVal_int(obj4, &val5);
47141 if (!SWIG_IsOK(ecode5)) {
47142 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47143 }
47144 arg5 = static_cast< int >(val5);
47145 }
47146 if (obj5) {
47147 ecode6 = SWIG_AsVal_int(obj5, &val6);
47148 if (!SWIG_IsOK(ecode6)) {
47149 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47150 }
47151 arg6 = static_cast< int >(val6);
47152 }
47153 if (obj6) {
47154 arg7 = obj6;
47155 }
47156 {
47157 PyThreadState* __tstate = wxPyBeginAllowThreads();
47158 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47159 wxPyEndAllowThreads(__tstate);
47160 if (PyErr_Occurred()) SWIG_fail;
47161 }
47162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47163 return resultobj;
47164 fail:
47165 return NULL;
47166 }
47167
47168
47169 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47170 PyObject *resultobj = 0;
47171 wxSizer *arg1 = (wxSizer *) 0 ;
47172 PyObject *arg2 = (PyObject *) 0 ;
47173 int arg3 = (int) 0 ;
47174 int arg4 = (int) 0 ;
47175 int arg5 = (int) 0 ;
47176 PyObject *arg6 = (PyObject *) NULL ;
47177 wxSizerItem *result = 0 ;
47178 void *argp1 = 0 ;
47179 int res1 = 0 ;
47180 int val3 ;
47181 int ecode3 = 0 ;
47182 int val4 ;
47183 int ecode4 = 0 ;
47184 int val5 ;
47185 int ecode5 = 0 ;
47186 PyObject * obj0 = 0 ;
47187 PyObject * obj1 = 0 ;
47188 PyObject * obj2 = 0 ;
47189 PyObject * obj3 = 0 ;
47190 PyObject * obj4 = 0 ;
47191 PyObject * obj5 = 0 ;
47192 char * kwnames[] = {
47193 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47194 };
47195
47196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47198 if (!SWIG_IsOK(res1)) {
47199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47200 }
47201 arg1 = reinterpret_cast< wxSizer * >(argp1);
47202 arg2 = obj1;
47203 if (obj2) {
47204 ecode3 = SWIG_AsVal_int(obj2, &val3);
47205 if (!SWIG_IsOK(ecode3)) {
47206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47207 }
47208 arg3 = static_cast< int >(val3);
47209 }
47210 if (obj3) {
47211 ecode4 = SWIG_AsVal_int(obj3, &val4);
47212 if (!SWIG_IsOK(ecode4)) {
47213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47214 }
47215 arg4 = static_cast< int >(val4);
47216 }
47217 if (obj4) {
47218 ecode5 = SWIG_AsVal_int(obj4, &val5);
47219 if (!SWIG_IsOK(ecode5)) {
47220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47221 }
47222 arg5 = static_cast< int >(val5);
47223 }
47224 if (obj5) {
47225 arg6 = obj5;
47226 }
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47234 return resultobj;
47235 fail:
47236 return NULL;
47237 }
47238
47239
47240 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47241 PyObject *resultobj = 0;
47242 wxSizer *arg1 = (wxSizer *) 0 ;
47243 PyObject *arg2 = (PyObject *) 0 ;
47244 bool result;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 PyObject * obj0 = 0 ;
47248 PyObject * obj1 = 0 ;
47249 char * kwnames[] = {
47250 (char *) "self",(char *) "item", NULL
47251 };
47252
47253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47255 if (!SWIG_IsOK(res1)) {
47256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47257 }
47258 arg1 = reinterpret_cast< wxSizer * >(argp1);
47259 arg2 = obj1;
47260 {
47261 PyThreadState* __tstate = wxPyBeginAllowThreads();
47262 result = (bool)wxSizer_Remove(arg1,arg2);
47263 wxPyEndAllowThreads(__tstate);
47264 if (PyErr_Occurred()) SWIG_fail;
47265 }
47266 {
47267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47268 }
47269 return resultobj;
47270 fail:
47271 return NULL;
47272 }
47273
47274
47275 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47276 PyObject *resultobj = 0;
47277 wxSizer *arg1 = (wxSizer *) 0 ;
47278 PyObject *arg2 = (PyObject *) 0 ;
47279 bool result;
47280 void *argp1 = 0 ;
47281 int res1 = 0 ;
47282 PyObject * obj0 = 0 ;
47283 PyObject * obj1 = 0 ;
47284 char * kwnames[] = {
47285 (char *) "self",(char *) "item", NULL
47286 };
47287
47288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47290 if (!SWIG_IsOK(res1)) {
47291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47292 }
47293 arg1 = reinterpret_cast< wxSizer * >(argp1);
47294 arg2 = obj1;
47295 {
47296 PyThreadState* __tstate = wxPyBeginAllowThreads();
47297 result = (bool)wxSizer_Detach(arg1,arg2);
47298 wxPyEndAllowThreads(__tstate);
47299 if (PyErr_Occurred()) SWIG_fail;
47300 }
47301 {
47302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47303 }
47304 return resultobj;
47305 fail:
47306 return NULL;
47307 }
47308
47309
47310 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47311 PyObject *resultobj = 0;
47312 wxSizer *arg1 = (wxSizer *) 0 ;
47313 PyObject *arg2 = (PyObject *) 0 ;
47314 wxSizerItem *result = 0 ;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 PyObject * obj0 = 0 ;
47318 PyObject * obj1 = 0 ;
47319 char * kwnames[] = {
47320 (char *) "self",(char *) "item", NULL
47321 };
47322
47323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47325 if (!SWIG_IsOK(res1)) {
47326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47327 }
47328 arg1 = reinterpret_cast< wxSizer * >(argp1);
47329 arg2 = obj1;
47330 {
47331 PyThreadState* __tstate = wxPyBeginAllowThreads();
47332 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47333 wxPyEndAllowThreads(__tstate);
47334 if (PyErr_Occurred()) SWIG_fail;
47335 }
47336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47344 PyObject *resultobj = 0;
47345 wxSizer *arg1 = (wxSizer *) 0 ;
47346 PyObject *arg2 = (PyObject *) 0 ;
47347 wxSize *arg3 = 0 ;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 wxSize temp3 ;
47351 PyObject * obj0 = 0 ;
47352 PyObject * obj1 = 0 ;
47353 PyObject * obj2 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "item",(char *) "size", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47362 }
47363 arg1 = reinterpret_cast< wxSizer * >(argp1);
47364 arg2 = obj1;
47365 {
47366 arg3 = &temp3;
47367 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47368 }
47369 {
47370 PyThreadState* __tstate = wxPyBeginAllowThreads();
47371 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47372 wxPyEndAllowThreads(__tstate);
47373 if (PyErr_Occurred()) SWIG_fail;
47374 }
47375 resultobj = SWIG_Py_Void();
47376 return resultobj;
47377 fail:
47378 return NULL;
47379 }
47380
47381
47382 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47383 PyObject *resultobj = 0;
47384 wxSizer *arg1 = (wxSizer *) 0 ;
47385 wxWindow *arg2 = (wxWindow *) 0 ;
47386 wxWindow *arg3 = (wxWindow *) 0 ;
47387 bool arg4 = (bool) false ;
47388 bool result;
47389 void *argp1 = 0 ;
47390 int res1 = 0 ;
47391 void *argp2 = 0 ;
47392 int res2 = 0 ;
47393 void *argp3 = 0 ;
47394 int res3 = 0 ;
47395 bool val4 ;
47396 int ecode4 = 0 ;
47397 PyObject * obj0 = 0 ;
47398 PyObject * obj1 = 0 ;
47399 PyObject * obj2 = 0 ;
47400 PyObject * obj3 = 0 ;
47401 char * kwnames[] = {
47402 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47403 };
47404
47405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47407 if (!SWIG_IsOK(res1)) {
47408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47409 }
47410 arg1 = reinterpret_cast< wxSizer * >(argp1);
47411 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47412 if (!SWIG_IsOK(res2)) {
47413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47414 }
47415 arg2 = reinterpret_cast< wxWindow * >(argp2);
47416 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47417 if (!SWIG_IsOK(res3)) {
47418 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47419 }
47420 arg3 = reinterpret_cast< wxWindow * >(argp3);
47421 if (obj3) {
47422 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47423 if (!SWIG_IsOK(ecode4)) {
47424 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47425 }
47426 arg4 = static_cast< bool >(val4);
47427 }
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47431 wxPyEndAllowThreads(__tstate);
47432 if (PyErr_Occurred()) SWIG_fail;
47433 }
47434 {
47435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47436 }
47437 return resultobj;
47438 fail:
47439 return NULL;
47440 }
47441
47442
47443 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47444 PyObject *resultobj = 0;
47445 wxSizer *arg1 = (wxSizer *) 0 ;
47446 wxSizer *arg2 = (wxSizer *) 0 ;
47447 wxSizer *arg3 = (wxSizer *) 0 ;
47448 bool arg4 = (bool) false ;
47449 bool result;
47450 void *argp1 = 0 ;
47451 int res1 = 0 ;
47452 void *argp2 = 0 ;
47453 int res2 = 0 ;
47454 void *argp3 = 0 ;
47455 int res3 = 0 ;
47456 bool val4 ;
47457 int ecode4 = 0 ;
47458 PyObject * obj0 = 0 ;
47459 PyObject * obj1 = 0 ;
47460 PyObject * obj2 = 0 ;
47461 PyObject * obj3 = 0 ;
47462 char * kwnames[] = {
47463 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47464 };
47465
47466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47470 }
47471 arg1 = reinterpret_cast< wxSizer * >(argp1);
47472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47473 if (!SWIG_IsOK(res2)) {
47474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47475 }
47476 arg2 = reinterpret_cast< wxSizer * >(argp2);
47477 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47478 if (!SWIG_IsOK(res3)) {
47479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47480 }
47481 arg3 = reinterpret_cast< wxSizer * >(argp3);
47482 if (obj3) {
47483 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47484 if (!SWIG_IsOK(ecode4)) {
47485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47486 }
47487 arg4 = static_cast< bool >(val4);
47488 }
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 {
47496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47497 }
47498 return resultobj;
47499 fail:
47500 return NULL;
47501 }
47502
47503
47504 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47505 PyObject *resultobj = 0;
47506 wxSizer *arg1 = (wxSizer *) 0 ;
47507 size_t arg2 ;
47508 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47509 bool result;
47510 void *argp1 = 0 ;
47511 int res1 = 0 ;
47512 size_t val2 ;
47513 int ecode2 = 0 ;
47514 void *argp3 = 0 ;
47515 int res3 = 0 ;
47516 PyObject * obj0 = 0 ;
47517 PyObject * obj1 = 0 ;
47518 PyObject * obj2 = 0 ;
47519 char * kwnames[] = {
47520 (char *) "self",(char *) "index",(char *) "newitem", NULL
47521 };
47522
47523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47525 if (!SWIG_IsOK(res1)) {
47526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47527 }
47528 arg1 = reinterpret_cast< wxSizer * >(argp1);
47529 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47530 if (!SWIG_IsOK(ecode2)) {
47531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47532 }
47533 arg2 = static_cast< size_t >(val2);
47534 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47535 if (!SWIG_IsOK(res3)) {
47536 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47537 }
47538 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47539 {
47540 PyThreadState* __tstate = wxPyBeginAllowThreads();
47541 result = (bool)(arg1)->Replace(arg2,arg3);
47542 wxPyEndAllowThreads(__tstate);
47543 if (PyErr_Occurred()) SWIG_fail;
47544 }
47545 {
47546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47547 }
47548 return resultobj;
47549 fail:
47550 return NULL;
47551 }
47552
47553
47554 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47555 PyObject *resultobj = 0;
47556 wxSizer *arg1 = (wxSizer *) 0 ;
47557 wxWindow *arg2 = (wxWindow *) 0 ;
47558 void *argp1 = 0 ;
47559 int res1 = 0 ;
47560 void *argp2 = 0 ;
47561 int res2 = 0 ;
47562 PyObject * obj0 = 0 ;
47563 PyObject * obj1 = 0 ;
47564 char * kwnames[] = {
47565 (char *) "self",(char *) "window", NULL
47566 };
47567
47568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47570 if (!SWIG_IsOK(res1)) {
47571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47572 }
47573 arg1 = reinterpret_cast< wxSizer * >(argp1);
47574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47575 if (!SWIG_IsOK(res2)) {
47576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47577 }
47578 arg2 = reinterpret_cast< wxWindow * >(argp2);
47579 {
47580 PyThreadState* __tstate = wxPyBeginAllowThreads();
47581 (arg1)->SetContainingWindow(arg2);
47582 wxPyEndAllowThreads(__tstate);
47583 if (PyErr_Occurred()) SWIG_fail;
47584 }
47585 resultobj = SWIG_Py_Void();
47586 return resultobj;
47587 fail:
47588 return NULL;
47589 }
47590
47591
47592 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47593 PyObject *resultobj = 0;
47594 wxSizer *arg1 = (wxSizer *) 0 ;
47595 wxWindow *result = 0 ;
47596 void *argp1 = 0 ;
47597 int res1 = 0 ;
47598 PyObject *swig_obj[1] ;
47599
47600 if (!args) SWIG_fail;
47601 swig_obj[0] = args;
47602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47603 if (!SWIG_IsOK(res1)) {
47604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47605 }
47606 arg1 = reinterpret_cast< wxSizer * >(argp1);
47607 {
47608 PyThreadState* __tstate = wxPyBeginAllowThreads();
47609 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47610 wxPyEndAllowThreads(__tstate);
47611 if (PyErr_Occurred()) SWIG_fail;
47612 }
47613 {
47614 resultobj = wxPyMake_wxObject(result, 0);
47615 }
47616 return resultobj;
47617 fail:
47618 return NULL;
47619 }
47620
47621
47622 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47623 PyObject *resultobj = 0;
47624 wxSizer *arg1 = (wxSizer *) 0 ;
47625 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47626 wxSizerItem *result = 0 ;
47627 void *argp1 = 0 ;
47628 int res1 = 0 ;
47629 int res2 = 0 ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 char * kwnames[] = {
47633 (char *) "self",(char *) "item", NULL
47634 };
47635
47636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47638 if (!SWIG_IsOK(res1)) {
47639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47640 }
47641 arg1 = reinterpret_cast< wxSizer * >(argp1);
47642 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47643 if (!SWIG_IsOK(res2)) {
47644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47645 }
47646 {
47647 PyThreadState* __tstate = wxPyBeginAllowThreads();
47648 result = (wxSizerItem *)(arg1)->Add(arg2);
47649 wxPyEndAllowThreads(__tstate);
47650 if (PyErr_Occurred()) SWIG_fail;
47651 }
47652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47653 return resultobj;
47654 fail:
47655 return NULL;
47656 }
47657
47658
47659 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47660 PyObject *resultobj = 0;
47661 wxSizer *arg1 = (wxSizer *) 0 ;
47662 size_t arg2 ;
47663 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47664 wxSizerItem *result = 0 ;
47665 void *argp1 = 0 ;
47666 int res1 = 0 ;
47667 size_t val2 ;
47668 int ecode2 = 0 ;
47669 int res3 = 0 ;
47670 PyObject * obj0 = 0 ;
47671 PyObject * obj1 = 0 ;
47672 PyObject * obj2 = 0 ;
47673 char * kwnames[] = {
47674 (char *) "self",(char *) "index",(char *) "item", NULL
47675 };
47676
47677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47679 if (!SWIG_IsOK(res1)) {
47680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47681 }
47682 arg1 = reinterpret_cast< wxSizer * >(argp1);
47683 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47684 if (!SWIG_IsOK(ecode2)) {
47685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47686 }
47687 arg2 = static_cast< size_t >(val2);
47688 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47689 if (!SWIG_IsOK(res3)) {
47690 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47691 }
47692 {
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47699 return resultobj;
47700 fail:
47701 return NULL;
47702 }
47703
47704
47705 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47706 PyObject *resultobj = 0;
47707 wxSizer *arg1 = (wxSizer *) 0 ;
47708 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47709 wxSizerItem *result = 0 ;
47710 void *argp1 = 0 ;
47711 int res1 = 0 ;
47712 int res2 = 0 ;
47713 PyObject * obj0 = 0 ;
47714 PyObject * obj1 = 0 ;
47715 char * kwnames[] = {
47716 (char *) "self",(char *) "item", NULL
47717 };
47718
47719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47721 if (!SWIG_IsOK(res1)) {
47722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47723 }
47724 arg1 = reinterpret_cast< wxSizer * >(argp1);
47725 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47726 if (!SWIG_IsOK(res2)) {
47727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47728 }
47729 {
47730 PyThreadState* __tstate = wxPyBeginAllowThreads();
47731 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47732 wxPyEndAllowThreads(__tstate);
47733 if (PyErr_Occurred()) SWIG_fail;
47734 }
47735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47736 return resultobj;
47737 fail:
47738 return NULL;
47739 }
47740
47741
47742 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47743 PyObject *resultobj = 0;
47744 wxSizer *arg1 = (wxSizer *) 0 ;
47745 int arg2 ;
47746 int arg3 ;
47747 int arg4 ;
47748 int arg5 ;
47749 void *argp1 = 0 ;
47750 int res1 = 0 ;
47751 int val2 ;
47752 int ecode2 = 0 ;
47753 int val3 ;
47754 int ecode3 = 0 ;
47755 int val4 ;
47756 int ecode4 = 0 ;
47757 int val5 ;
47758 int ecode5 = 0 ;
47759 PyObject * obj0 = 0 ;
47760 PyObject * obj1 = 0 ;
47761 PyObject * obj2 = 0 ;
47762 PyObject * obj3 = 0 ;
47763 PyObject * obj4 = 0 ;
47764 char * kwnames[] = {
47765 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47766 };
47767
47768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47770 if (!SWIG_IsOK(res1)) {
47771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47772 }
47773 arg1 = reinterpret_cast< wxSizer * >(argp1);
47774 ecode2 = SWIG_AsVal_int(obj1, &val2);
47775 if (!SWIG_IsOK(ecode2)) {
47776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47777 }
47778 arg2 = static_cast< int >(val2);
47779 ecode3 = SWIG_AsVal_int(obj2, &val3);
47780 if (!SWIG_IsOK(ecode3)) {
47781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47782 }
47783 arg3 = static_cast< int >(val3);
47784 ecode4 = SWIG_AsVal_int(obj3, &val4);
47785 if (!SWIG_IsOK(ecode4)) {
47786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47787 }
47788 arg4 = static_cast< int >(val4);
47789 ecode5 = SWIG_AsVal_int(obj4, &val5);
47790 if (!SWIG_IsOK(ecode5)) {
47791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47792 }
47793 arg5 = static_cast< int >(val5);
47794 {
47795 PyThreadState* __tstate = wxPyBeginAllowThreads();
47796 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47797 wxPyEndAllowThreads(__tstate);
47798 if (PyErr_Occurred()) SWIG_fail;
47799 }
47800 resultobj = SWIG_Py_Void();
47801 return resultobj;
47802 fail:
47803 return NULL;
47804 }
47805
47806
47807 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47808 PyObject *resultobj = 0;
47809 wxSizer *arg1 = (wxSizer *) 0 ;
47810 wxSize *arg2 = 0 ;
47811 void *argp1 = 0 ;
47812 int res1 = 0 ;
47813 wxSize temp2 ;
47814 PyObject * obj0 = 0 ;
47815 PyObject * obj1 = 0 ;
47816 char * kwnames[] = {
47817 (char *) "self",(char *) "size", NULL
47818 };
47819
47820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47822 if (!SWIG_IsOK(res1)) {
47823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47824 }
47825 arg1 = reinterpret_cast< wxSizer * >(argp1);
47826 {
47827 arg2 = &temp2;
47828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47829 }
47830 {
47831 PyThreadState* __tstate = wxPyBeginAllowThreads();
47832 (arg1)->SetMinSize((wxSize const &)*arg2);
47833 wxPyEndAllowThreads(__tstate);
47834 if (PyErr_Occurred()) SWIG_fail;
47835 }
47836 resultobj = SWIG_Py_Void();
47837 return resultobj;
47838 fail:
47839 return NULL;
47840 }
47841
47842
47843 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47844 PyObject *resultobj = 0;
47845 wxSizer *arg1 = (wxSizer *) 0 ;
47846 wxSize result;
47847 void *argp1 = 0 ;
47848 int res1 = 0 ;
47849 PyObject *swig_obj[1] ;
47850
47851 if (!args) SWIG_fail;
47852 swig_obj[0] = args;
47853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47854 if (!SWIG_IsOK(res1)) {
47855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47856 }
47857 arg1 = reinterpret_cast< wxSizer * >(argp1);
47858 {
47859 PyThreadState* __tstate = wxPyBeginAllowThreads();
47860 result = (arg1)->GetSize();
47861 wxPyEndAllowThreads(__tstate);
47862 if (PyErr_Occurred()) SWIG_fail;
47863 }
47864 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47865 return resultobj;
47866 fail:
47867 return NULL;
47868 }
47869
47870
47871 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47872 PyObject *resultobj = 0;
47873 wxSizer *arg1 = (wxSizer *) 0 ;
47874 wxPoint result;
47875 void *argp1 = 0 ;
47876 int res1 = 0 ;
47877 PyObject *swig_obj[1] ;
47878
47879 if (!args) SWIG_fail;
47880 swig_obj[0] = args;
47881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47882 if (!SWIG_IsOK(res1)) {
47883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47884 }
47885 arg1 = reinterpret_cast< wxSizer * >(argp1);
47886 {
47887 PyThreadState* __tstate = wxPyBeginAllowThreads();
47888 result = (arg1)->GetPosition();
47889 wxPyEndAllowThreads(__tstate);
47890 if (PyErr_Occurred()) SWIG_fail;
47891 }
47892 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47893 return resultobj;
47894 fail:
47895 return NULL;
47896 }
47897
47898
47899 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47900 PyObject *resultobj = 0;
47901 wxSizer *arg1 = (wxSizer *) 0 ;
47902 wxSize result;
47903 void *argp1 = 0 ;
47904 int res1 = 0 ;
47905 PyObject *swig_obj[1] ;
47906
47907 if (!args) SWIG_fail;
47908 swig_obj[0] = args;
47909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47910 if (!SWIG_IsOK(res1)) {
47911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47912 }
47913 arg1 = reinterpret_cast< wxSizer * >(argp1);
47914 {
47915 PyThreadState* __tstate = wxPyBeginAllowThreads();
47916 result = (arg1)->GetMinSize();
47917 wxPyEndAllowThreads(__tstate);
47918 if (PyErr_Occurred()) SWIG_fail;
47919 }
47920 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47921 return resultobj;
47922 fail:
47923 return NULL;
47924 }
47925
47926
47927 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47928 PyObject *resultobj = 0;
47929 wxSizer *arg1 = (wxSizer *) 0 ;
47930 void *argp1 = 0 ;
47931 int res1 = 0 ;
47932 PyObject *swig_obj[1] ;
47933
47934 if (!args) SWIG_fail;
47935 swig_obj[0] = args;
47936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47937 if (!SWIG_IsOK(res1)) {
47938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47939 }
47940 arg1 = reinterpret_cast< wxSizer * >(argp1);
47941 {
47942 PyThreadState* __tstate = wxPyBeginAllowThreads();
47943 (arg1)->RecalcSizes();
47944 wxPyEndAllowThreads(__tstate);
47945 if (PyErr_Occurred()) SWIG_fail;
47946 }
47947 resultobj = SWIG_Py_Void();
47948 return resultobj;
47949 fail:
47950 return NULL;
47951 }
47952
47953
47954 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47955 PyObject *resultobj = 0;
47956 wxSizer *arg1 = (wxSizer *) 0 ;
47957 wxSize result;
47958 void *argp1 = 0 ;
47959 int res1 = 0 ;
47960 PyObject *swig_obj[1] ;
47961
47962 if (!args) SWIG_fail;
47963 swig_obj[0] = args;
47964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47965 if (!SWIG_IsOK(res1)) {
47966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47967 }
47968 arg1 = reinterpret_cast< wxSizer * >(argp1);
47969 {
47970 PyThreadState* __tstate = wxPyBeginAllowThreads();
47971 result = (arg1)->CalcMin();
47972 wxPyEndAllowThreads(__tstate);
47973 if (PyErr_Occurred()) SWIG_fail;
47974 }
47975 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47976 return resultobj;
47977 fail:
47978 return NULL;
47979 }
47980
47981
47982 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47983 PyObject *resultobj = 0;
47984 wxSizer *arg1 = (wxSizer *) 0 ;
47985 void *argp1 = 0 ;
47986 int res1 = 0 ;
47987 PyObject *swig_obj[1] ;
47988
47989 if (!args) SWIG_fail;
47990 swig_obj[0] = args;
47991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47992 if (!SWIG_IsOK(res1)) {
47993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47994 }
47995 arg1 = reinterpret_cast< wxSizer * >(argp1);
47996 {
47997 PyThreadState* __tstate = wxPyBeginAllowThreads();
47998 (arg1)->Layout();
47999 wxPyEndAllowThreads(__tstate);
48000 if (PyErr_Occurred()) SWIG_fail;
48001 }
48002 resultobj = SWIG_Py_Void();
48003 return resultobj;
48004 fail:
48005 return NULL;
48006 }
48007
48008
48009 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48010 PyObject *resultobj = 0;
48011 wxSizer *arg1 = (wxSizer *) 0 ;
48012 wxWindow *arg2 = (wxWindow *) 0 ;
48013 wxSize result;
48014 void *argp1 = 0 ;
48015 int res1 = 0 ;
48016 void *argp2 = 0 ;
48017 int res2 = 0 ;
48018 PyObject * obj0 = 0 ;
48019 PyObject * obj1 = 0 ;
48020 char * kwnames[] = {
48021 (char *) "self",(char *) "window", NULL
48022 };
48023
48024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48026 if (!SWIG_IsOK(res1)) {
48027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48028 }
48029 arg1 = reinterpret_cast< wxSizer * >(argp1);
48030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48031 if (!SWIG_IsOK(res2)) {
48032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48033 }
48034 arg2 = reinterpret_cast< wxWindow * >(argp2);
48035 {
48036 PyThreadState* __tstate = wxPyBeginAllowThreads();
48037 result = (arg1)->Fit(arg2);
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48049 PyObject *resultobj = 0;
48050 wxSizer *arg1 = (wxSizer *) 0 ;
48051 wxWindow *arg2 = (wxWindow *) 0 ;
48052 void *argp1 = 0 ;
48053 int res1 = 0 ;
48054 void *argp2 = 0 ;
48055 int res2 = 0 ;
48056 PyObject * obj0 = 0 ;
48057 PyObject * obj1 = 0 ;
48058 char * kwnames[] = {
48059 (char *) "self",(char *) "window", NULL
48060 };
48061
48062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48064 if (!SWIG_IsOK(res1)) {
48065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48066 }
48067 arg1 = reinterpret_cast< wxSizer * >(argp1);
48068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48069 if (!SWIG_IsOK(res2)) {
48070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48071 }
48072 arg2 = reinterpret_cast< wxWindow * >(argp2);
48073 {
48074 PyThreadState* __tstate = wxPyBeginAllowThreads();
48075 (arg1)->FitInside(arg2);
48076 wxPyEndAllowThreads(__tstate);
48077 if (PyErr_Occurred()) SWIG_fail;
48078 }
48079 resultobj = SWIG_Py_Void();
48080 return resultobj;
48081 fail:
48082 return NULL;
48083 }
48084
48085
48086 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48087 PyObject *resultobj = 0;
48088 wxSizer *arg1 = (wxSizer *) 0 ;
48089 wxWindow *arg2 = (wxWindow *) 0 ;
48090 void *argp1 = 0 ;
48091 int res1 = 0 ;
48092 void *argp2 = 0 ;
48093 int res2 = 0 ;
48094 PyObject * obj0 = 0 ;
48095 PyObject * obj1 = 0 ;
48096 char * kwnames[] = {
48097 (char *) "self",(char *) "window", NULL
48098 };
48099
48100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48102 if (!SWIG_IsOK(res1)) {
48103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48104 }
48105 arg1 = reinterpret_cast< wxSizer * >(argp1);
48106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48107 if (!SWIG_IsOK(res2)) {
48108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48109 }
48110 arg2 = reinterpret_cast< wxWindow * >(argp2);
48111 {
48112 PyThreadState* __tstate = wxPyBeginAllowThreads();
48113 (arg1)->SetSizeHints(arg2);
48114 wxPyEndAllowThreads(__tstate);
48115 if (PyErr_Occurred()) SWIG_fail;
48116 }
48117 resultobj = SWIG_Py_Void();
48118 return resultobj;
48119 fail:
48120 return NULL;
48121 }
48122
48123
48124 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48125 PyObject *resultobj = 0;
48126 wxSizer *arg1 = (wxSizer *) 0 ;
48127 wxWindow *arg2 = (wxWindow *) 0 ;
48128 void *argp1 = 0 ;
48129 int res1 = 0 ;
48130 void *argp2 = 0 ;
48131 int res2 = 0 ;
48132 PyObject * obj0 = 0 ;
48133 PyObject * obj1 = 0 ;
48134 char * kwnames[] = {
48135 (char *) "self",(char *) "window", NULL
48136 };
48137
48138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48140 if (!SWIG_IsOK(res1)) {
48141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48142 }
48143 arg1 = reinterpret_cast< wxSizer * >(argp1);
48144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48145 if (!SWIG_IsOK(res2)) {
48146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48147 }
48148 arg2 = reinterpret_cast< wxWindow * >(argp2);
48149 {
48150 PyThreadState* __tstate = wxPyBeginAllowThreads();
48151 (arg1)->SetVirtualSizeHints(arg2);
48152 wxPyEndAllowThreads(__tstate);
48153 if (PyErr_Occurred()) SWIG_fail;
48154 }
48155 resultobj = SWIG_Py_Void();
48156 return resultobj;
48157 fail:
48158 return NULL;
48159 }
48160
48161
48162 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48163 PyObject *resultobj = 0;
48164 wxSizer *arg1 = (wxSizer *) 0 ;
48165 bool arg2 = (bool) false ;
48166 void *argp1 = 0 ;
48167 int res1 = 0 ;
48168 bool val2 ;
48169 int ecode2 = 0 ;
48170 PyObject * obj0 = 0 ;
48171 PyObject * obj1 = 0 ;
48172 char * kwnames[] = {
48173 (char *) "self",(char *) "deleteWindows", NULL
48174 };
48175
48176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48178 if (!SWIG_IsOK(res1)) {
48179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48180 }
48181 arg1 = reinterpret_cast< wxSizer * >(argp1);
48182 if (obj1) {
48183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48184 if (!SWIG_IsOK(ecode2)) {
48185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48186 }
48187 arg2 = static_cast< bool >(val2);
48188 }
48189 {
48190 PyThreadState* __tstate = wxPyBeginAllowThreads();
48191 (arg1)->Clear(arg2);
48192 wxPyEndAllowThreads(__tstate);
48193 if (PyErr_Occurred()) SWIG_fail;
48194 }
48195 resultobj = SWIG_Py_Void();
48196 return resultobj;
48197 fail:
48198 return NULL;
48199 }
48200
48201
48202 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48203 PyObject *resultobj = 0;
48204 wxSizer *arg1 = (wxSizer *) 0 ;
48205 void *argp1 = 0 ;
48206 int res1 = 0 ;
48207 PyObject *swig_obj[1] ;
48208
48209 if (!args) SWIG_fail;
48210 swig_obj[0] = args;
48211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48212 if (!SWIG_IsOK(res1)) {
48213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48214 }
48215 arg1 = reinterpret_cast< wxSizer * >(argp1);
48216 {
48217 PyThreadState* __tstate = wxPyBeginAllowThreads();
48218 (arg1)->DeleteWindows();
48219 wxPyEndAllowThreads(__tstate);
48220 if (PyErr_Occurred()) SWIG_fail;
48221 }
48222 resultobj = SWIG_Py_Void();
48223 return resultobj;
48224 fail:
48225 return NULL;
48226 }
48227
48228
48229 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48230 PyObject *resultobj = 0;
48231 wxSizer *arg1 = (wxSizer *) 0 ;
48232 PyObject *result = 0 ;
48233 void *argp1 = 0 ;
48234 int res1 = 0 ;
48235 PyObject *swig_obj[1] ;
48236
48237 if (!args) SWIG_fail;
48238 swig_obj[0] = args;
48239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48240 if (!SWIG_IsOK(res1)) {
48241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48242 }
48243 arg1 = reinterpret_cast< wxSizer * >(argp1);
48244 {
48245 PyThreadState* __tstate = wxPyBeginAllowThreads();
48246 result = (PyObject *)wxSizer_GetChildren(arg1);
48247 wxPyEndAllowThreads(__tstate);
48248 if (PyErr_Occurred()) SWIG_fail;
48249 }
48250 resultobj = result;
48251 return resultobj;
48252 fail:
48253 return NULL;
48254 }
48255
48256
48257 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48258 PyObject *resultobj = 0;
48259 wxSizer *arg1 = (wxSizer *) 0 ;
48260 PyObject *arg2 = (PyObject *) 0 ;
48261 bool arg3 = (bool) true ;
48262 bool arg4 = (bool) false ;
48263 bool result;
48264 void *argp1 = 0 ;
48265 int res1 = 0 ;
48266 bool val3 ;
48267 int ecode3 = 0 ;
48268 bool val4 ;
48269 int ecode4 = 0 ;
48270 PyObject * obj0 = 0 ;
48271 PyObject * obj1 = 0 ;
48272 PyObject * obj2 = 0 ;
48273 PyObject * obj3 = 0 ;
48274 char * kwnames[] = {
48275 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48276 };
48277
48278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48280 if (!SWIG_IsOK(res1)) {
48281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48282 }
48283 arg1 = reinterpret_cast< wxSizer * >(argp1);
48284 arg2 = obj1;
48285 if (obj2) {
48286 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48287 if (!SWIG_IsOK(ecode3)) {
48288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48289 }
48290 arg3 = static_cast< bool >(val3);
48291 }
48292 if (obj3) {
48293 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48294 if (!SWIG_IsOK(ecode4)) {
48295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48296 }
48297 arg4 = static_cast< bool >(val4);
48298 }
48299 {
48300 PyThreadState* __tstate = wxPyBeginAllowThreads();
48301 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48302 wxPyEndAllowThreads(__tstate);
48303 if (PyErr_Occurred()) SWIG_fail;
48304 }
48305 {
48306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48307 }
48308 return resultobj;
48309 fail:
48310 return NULL;
48311 }
48312
48313
48314 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48315 PyObject *resultobj = 0;
48316 wxSizer *arg1 = (wxSizer *) 0 ;
48317 PyObject *arg2 = (PyObject *) 0 ;
48318 bool result;
48319 void *argp1 = 0 ;
48320 int res1 = 0 ;
48321 PyObject * obj0 = 0 ;
48322 PyObject * obj1 = 0 ;
48323 char * kwnames[] = {
48324 (char *) "self",(char *) "item", NULL
48325 };
48326
48327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48329 if (!SWIG_IsOK(res1)) {
48330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48331 }
48332 arg1 = reinterpret_cast< wxSizer * >(argp1);
48333 arg2 = obj1;
48334 {
48335 PyThreadState* __tstate = wxPyBeginAllowThreads();
48336 result = (bool)wxSizer_IsShown(arg1,arg2);
48337 wxPyEndAllowThreads(__tstate);
48338 if (PyErr_Occurred()) SWIG_fail;
48339 }
48340 {
48341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48342 }
48343 return resultobj;
48344 fail:
48345 return NULL;
48346 }
48347
48348
48349 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48350 PyObject *resultobj = 0;
48351 wxSizer *arg1 = (wxSizer *) 0 ;
48352 bool arg2 ;
48353 void *argp1 = 0 ;
48354 int res1 = 0 ;
48355 bool val2 ;
48356 int ecode2 = 0 ;
48357 PyObject * obj0 = 0 ;
48358 PyObject * obj1 = 0 ;
48359 char * kwnames[] = {
48360 (char *) "self",(char *) "show", NULL
48361 };
48362
48363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48365 if (!SWIG_IsOK(res1)) {
48366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48367 }
48368 arg1 = reinterpret_cast< wxSizer * >(argp1);
48369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48370 if (!SWIG_IsOK(ecode2)) {
48371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48372 }
48373 arg2 = static_cast< bool >(val2);
48374 {
48375 PyThreadState* __tstate = wxPyBeginAllowThreads();
48376 (arg1)->ShowItems(arg2);
48377 wxPyEndAllowThreads(__tstate);
48378 if (PyErr_Occurred()) SWIG_fail;
48379 }
48380 resultobj = SWIG_Py_Void();
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48388 PyObject *obj;
48389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48390 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48391 return SWIG_Py_Void();
48392 }
48393
48394 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48395 PyObject *resultobj = 0;
48396 wxPySizer *result = 0 ;
48397
48398 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48399 {
48400 PyThreadState* __tstate = wxPyBeginAllowThreads();
48401 result = (wxPySizer *)new wxPySizer();
48402 wxPyEndAllowThreads(__tstate);
48403 if (PyErr_Occurred()) SWIG_fail;
48404 }
48405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48406 return resultobj;
48407 fail:
48408 return NULL;
48409 }
48410
48411
48412 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48413 PyObject *resultobj = 0;
48414 wxPySizer *arg1 = (wxPySizer *) 0 ;
48415 PyObject *arg2 = (PyObject *) 0 ;
48416 PyObject *arg3 = (PyObject *) 0 ;
48417 void *argp1 = 0 ;
48418 int res1 = 0 ;
48419 PyObject * obj0 = 0 ;
48420 PyObject * obj1 = 0 ;
48421 PyObject * obj2 = 0 ;
48422 char * kwnames[] = {
48423 (char *) "self",(char *) "self",(char *) "_class", NULL
48424 };
48425
48426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48428 if (!SWIG_IsOK(res1)) {
48429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48430 }
48431 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48432 arg2 = obj1;
48433 arg3 = obj2;
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 (arg1)->_setCallbackInfo(arg2,arg3);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 resultobj = SWIG_Py_Void();
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48448 PyObject *obj;
48449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48450 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48451 return SWIG_Py_Void();
48452 }
48453
48454 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48455 return SWIG_Python_InitShadowInstance(args);
48456 }
48457
48458 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48459 PyObject *resultobj = 0;
48460 int arg1 = (int) wxHORIZONTAL ;
48461 wxBoxSizer *result = 0 ;
48462 int val1 ;
48463 int ecode1 = 0 ;
48464 PyObject * obj0 = 0 ;
48465 char * kwnames[] = {
48466 (char *) "orient", NULL
48467 };
48468
48469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48470 if (obj0) {
48471 ecode1 = SWIG_AsVal_int(obj0, &val1);
48472 if (!SWIG_IsOK(ecode1)) {
48473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48474 }
48475 arg1 = static_cast< int >(val1);
48476 }
48477 {
48478 PyThreadState* __tstate = wxPyBeginAllowThreads();
48479 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48480 wxPyEndAllowThreads(__tstate);
48481 if (PyErr_Occurred()) SWIG_fail;
48482 }
48483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48484 return resultobj;
48485 fail:
48486 return NULL;
48487 }
48488
48489
48490 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48491 PyObject *resultobj = 0;
48492 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48493 int result;
48494 void *argp1 = 0 ;
48495 int res1 = 0 ;
48496 PyObject *swig_obj[1] ;
48497
48498 if (!args) SWIG_fail;
48499 swig_obj[0] = args;
48500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48501 if (!SWIG_IsOK(res1)) {
48502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48503 }
48504 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48505 {
48506 PyThreadState* __tstate = wxPyBeginAllowThreads();
48507 result = (int)(arg1)->GetOrientation();
48508 wxPyEndAllowThreads(__tstate);
48509 if (PyErr_Occurred()) SWIG_fail;
48510 }
48511 resultobj = SWIG_From_int(static_cast< int >(result));
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48521 int arg2 ;
48522 void *argp1 = 0 ;
48523 int res1 = 0 ;
48524 int val2 ;
48525 int ecode2 = 0 ;
48526 PyObject * obj0 = 0 ;
48527 PyObject * obj1 = 0 ;
48528 char * kwnames[] = {
48529 (char *) "self",(char *) "orient", NULL
48530 };
48531
48532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48534 if (!SWIG_IsOK(res1)) {
48535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48536 }
48537 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48538 ecode2 = SWIG_AsVal_int(obj1, &val2);
48539 if (!SWIG_IsOK(ecode2)) {
48540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48541 }
48542 arg2 = static_cast< int >(val2);
48543 {
48544 PyThreadState* __tstate = wxPyBeginAllowThreads();
48545 (arg1)->SetOrientation(arg2);
48546 wxPyEndAllowThreads(__tstate);
48547 if (PyErr_Occurred()) SWIG_fail;
48548 }
48549 resultobj = SWIG_Py_Void();
48550 return resultobj;
48551 fail:
48552 return NULL;
48553 }
48554
48555
48556 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48557 PyObject *obj;
48558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48559 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48560 return SWIG_Py_Void();
48561 }
48562
48563 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48564 return SWIG_Python_InitShadowInstance(args);
48565 }
48566
48567 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48568 PyObject *resultobj = 0;
48569 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48570 int arg2 = (int) wxHORIZONTAL ;
48571 wxStaticBoxSizer *result = 0 ;
48572 void *argp1 = 0 ;
48573 int res1 = 0 ;
48574 int val2 ;
48575 int ecode2 = 0 ;
48576 PyObject * obj0 = 0 ;
48577 PyObject * obj1 = 0 ;
48578 char * kwnames[] = {
48579 (char *) "box",(char *) "orient", NULL
48580 };
48581
48582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48584 if (!SWIG_IsOK(res1)) {
48585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48586 }
48587 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48588 if (obj1) {
48589 ecode2 = SWIG_AsVal_int(obj1, &val2);
48590 if (!SWIG_IsOK(ecode2)) {
48591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48592 }
48593 arg2 = static_cast< int >(val2);
48594 }
48595 {
48596 PyThreadState* __tstate = wxPyBeginAllowThreads();
48597 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48598 wxPyEndAllowThreads(__tstate);
48599 if (PyErr_Occurred()) SWIG_fail;
48600 }
48601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48602 return resultobj;
48603 fail:
48604 return NULL;
48605 }
48606
48607
48608 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48609 PyObject *resultobj = 0;
48610 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48611 wxStaticBox *result = 0 ;
48612 void *argp1 = 0 ;
48613 int res1 = 0 ;
48614 PyObject *swig_obj[1] ;
48615
48616 if (!args) SWIG_fail;
48617 swig_obj[0] = args;
48618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48619 if (!SWIG_IsOK(res1)) {
48620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48621 }
48622 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48623 {
48624 PyThreadState* __tstate = wxPyBeginAllowThreads();
48625 result = (wxStaticBox *)(arg1)->GetStaticBox();
48626 wxPyEndAllowThreads(__tstate);
48627 if (PyErr_Occurred()) SWIG_fail;
48628 }
48629 {
48630 resultobj = wxPyMake_wxObject(result, (bool)0);
48631 }
48632 return resultobj;
48633 fail:
48634 return NULL;
48635 }
48636
48637
48638 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48639 PyObject *obj;
48640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48641 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48642 return SWIG_Py_Void();
48643 }
48644
48645 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48646 return SWIG_Python_InitShadowInstance(args);
48647 }
48648
48649 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48650 PyObject *resultobj = 0;
48651 int arg1 = (int) 1 ;
48652 int arg2 = (int) 0 ;
48653 int arg3 = (int) 0 ;
48654 int arg4 = (int) 0 ;
48655 wxGridSizer *result = 0 ;
48656 int val1 ;
48657 int ecode1 = 0 ;
48658 int val2 ;
48659 int ecode2 = 0 ;
48660 int val3 ;
48661 int ecode3 = 0 ;
48662 int val4 ;
48663 int ecode4 = 0 ;
48664 PyObject * obj0 = 0 ;
48665 PyObject * obj1 = 0 ;
48666 PyObject * obj2 = 0 ;
48667 PyObject * obj3 = 0 ;
48668 char * kwnames[] = {
48669 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48670 };
48671
48672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48673 if (obj0) {
48674 ecode1 = SWIG_AsVal_int(obj0, &val1);
48675 if (!SWIG_IsOK(ecode1)) {
48676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48677 }
48678 arg1 = static_cast< int >(val1);
48679 }
48680 if (obj1) {
48681 ecode2 = SWIG_AsVal_int(obj1, &val2);
48682 if (!SWIG_IsOK(ecode2)) {
48683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48684 }
48685 arg2 = static_cast< int >(val2);
48686 }
48687 if (obj2) {
48688 ecode3 = SWIG_AsVal_int(obj2, &val3);
48689 if (!SWIG_IsOK(ecode3)) {
48690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48691 }
48692 arg3 = static_cast< int >(val3);
48693 }
48694 if (obj3) {
48695 ecode4 = SWIG_AsVal_int(obj3, &val4);
48696 if (!SWIG_IsOK(ecode4)) {
48697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48698 }
48699 arg4 = static_cast< int >(val4);
48700 }
48701 {
48702 PyThreadState* __tstate = wxPyBeginAllowThreads();
48703 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48704 wxPyEndAllowThreads(__tstate);
48705 if (PyErr_Occurred()) SWIG_fail;
48706 }
48707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48708 return resultobj;
48709 fail:
48710 return NULL;
48711 }
48712
48713
48714 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48715 PyObject *resultobj = 0;
48716 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48717 int arg2 ;
48718 void *argp1 = 0 ;
48719 int res1 = 0 ;
48720 int val2 ;
48721 int ecode2 = 0 ;
48722 PyObject * obj0 = 0 ;
48723 PyObject * obj1 = 0 ;
48724 char * kwnames[] = {
48725 (char *) "self",(char *) "cols", NULL
48726 };
48727
48728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48730 if (!SWIG_IsOK(res1)) {
48731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48732 }
48733 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48734 ecode2 = SWIG_AsVal_int(obj1, &val2);
48735 if (!SWIG_IsOK(ecode2)) {
48736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48737 }
48738 arg2 = static_cast< int >(val2);
48739 {
48740 PyThreadState* __tstate = wxPyBeginAllowThreads();
48741 (arg1)->SetCols(arg2);
48742 wxPyEndAllowThreads(__tstate);
48743 if (PyErr_Occurred()) SWIG_fail;
48744 }
48745 resultobj = SWIG_Py_Void();
48746 return resultobj;
48747 fail:
48748 return NULL;
48749 }
48750
48751
48752 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48753 PyObject *resultobj = 0;
48754 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48755 int arg2 ;
48756 void *argp1 = 0 ;
48757 int res1 = 0 ;
48758 int val2 ;
48759 int ecode2 = 0 ;
48760 PyObject * obj0 = 0 ;
48761 PyObject * obj1 = 0 ;
48762 char * kwnames[] = {
48763 (char *) "self",(char *) "rows", NULL
48764 };
48765
48766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48768 if (!SWIG_IsOK(res1)) {
48769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48770 }
48771 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48772 ecode2 = SWIG_AsVal_int(obj1, &val2);
48773 if (!SWIG_IsOK(ecode2)) {
48774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48775 }
48776 arg2 = static_cast< int >(val2);
48777 {
48778 PyThreadState* __tstate = wxPyBeginAllowThreads();
48779 (arg1)->SetRows(arg2);
48780 wxPyEndAllowThreads(__tstate);
48781 if (PyErr_Occurred()) SWIG_fail;
48782 }
48783 resultobj = SWIG_Py_Void();
48784 return resultobj;
48785 fail:
48786 return NULL;
48787 }
48788
48789
48790 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48791 PyObject *resultobj = 0;
48792 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48793 int arg2 ;
48794 void *argp1 = 0 ;
48795 int res1 = 0 ;
48796 int val2 ;
48797 int ecode2 = 0 ;
48798 PyObject * obj0 = 0 ;
48799 PyObject * obj1 = 0 ;
48800 char * kwnames[] = {
48801 (char *) "self",(char *) "gap", NULL
48802 };
48803
48804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48806 if (!SWIG_IsOK(res1)) {
48807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48808 }
48809 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48810 ecode2 = SWIG_AsVal_int(obj1, &val2);
48811 if (!SWIG_IsOK(ecode2)) {
48812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48813 }
48814 arg2 = static_cast< int >(val2);
48815 {
48816 PyThreadState* __tstate = wxPyBeginAllowThreads();
48817 (arg1)->SetVGap(arg2);
48818 wxPyEndAllowThreads(__tstate);
48819 if (PyErr_Occurred()) SWIG_fail;
48820 }
48821 resultobj = SWIG_Py_Void();
48822 return resultobj;
48823 fail:
48824 return NULL;
48825 }
48826
48827
48828 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48829 PyObject *resultobj = 0;
48830 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48831 int arg2 ;
48832 void *argp1 = 0 ;
48833 int res1 = 0 ;
48834 int val2 ;
48835 int ecode2 = 0 ;
48836 PyObject * obj0 = 0 ;
48837 PyObject * obj1 = 0 ;
48838 char * kwnames[] = {
48839 (char *) "self",(char *) "gap", NULL
48840 };
48841
48842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48844 if (!SWIG_IsOK(res1)) {
48845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48846 }
48847 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48848 ecode2 = SWIG_AsVal_int(obj1, &val2);
48849 if (!SWIG_IsOK(ecode2)) {
48850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48851 }
48852 arg2 = static_cast< int >(val2);
48853 {
48854 PyThreadState* __tstate = wxPyBeginAllowThreads();
48855 (arg1)->SetHGap(arg2);
48856 wxPyEndAllowThreads(__tstate);
48857 if (PyErr_Occurred()) SWIG_fail;
48858 }
48859 resultobj = SWIG_Py_Void();
48860 return resultobj;
48861 fail:
48862 return NULL;
48863 }
48864
48865
48866 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48867 PyObject *resultobj = 0;
48868 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48869 int result;
48870 void *argp1 = 0 ;
48871 int res1 = 0 ;
48872 PyObject *swig_obj[1] ;
48873
48874 if (!args) SWIG_fail;
48875 swig_obj[0] = args;
48876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48877 if (!SWIG_IsOK(res1)) {
48878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48879 }
48880 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48881 {
48882 PyThreadState* __tstate = wxPyBeginAllowThreads();
48883 result = (int)(arg1)->GetCols();
48884 wxPyEndAllowThreads(__tstate);
48885 if (PyErr_Occurred()) SWIG_fail;
48886 }
48887 resultobj = SWIG_From_int(static_cast< int >(result));
48888 return resultobj;
48889 fail:
48890 return NULL;
48891 }
48892
48893
48894 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48895 PyObject *resultobj = 0;
48896 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48897 int result;
48898 void *argp1 = 0 ;
48899 int res1 = 0 ;
48900 PyObject *swig_obj[1] ;
48901
48902 if (!args) SWIG_fail;
48903 swig_obj[0] = args;
48904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48905 if (!SWIG_IsOK(res1)) {
48906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48907 }
48908 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48909 {
48910 PyThreadState* __tstate = wxPyBeginAllowThreads();
48911 result = (int)(arg1)->GetRows();
48912 wxPyEndAllowThreads(__tstate);
48913 if (PyErr_Occurred()) SWIG_fail;
48914 }
48915 resultobj = SWIG_From_int(static_cast< int >(result));
48916 return resultobj;
48917 fail:
48918 return NULL;
48919 }
48920
48921
48922 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48923 PyObject *resultobj = 0;
48924 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48925 int result;
48926 void *argp1 = 0 ;
48927 int res1 = 0 ;
48928 PyObject *swig_obj[1] ;
48929
48930 if (!args) SWIG_fail;
48931 swig_obj[0] = args;
48932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48933 if (!SWIG_IsOK(res1)) {
48934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48935 }
48936 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48937 {
48938 PyThreadState* __tstate = wxPyBeginAllowThreads();
48939 result = (int)(arg1)->GetVGap();
48940 wxPyEndAllowThreads(__tstate);
48941 if (PyErr_Occurred()) SWIG_fail;
48942 }
48943 resultobj = SWIG_From_int(static_cast< int >(result));
48944 return resultobj;
48945 fail:
48946 return NULL;
48947 }
48948
48949
48950 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48951 PyObject *resultobj = 0;
48952 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48953 int result;
48954 void *argp1 = 0 ;
48955 int res1 = 0 ;
48956 PyObject *swig_obj[1] ;
48957
48958 if (!args) SWIG_fail;
48959 swig_obj[0] = args;
48960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48961 if (!SWIG_IsOK(res1)) {
48962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48963 }
48964 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48965 {
48966 PyThreadState* __tstate = wxPyBeginAllowThreads();
48967 result = (int)(arg1)->GetHGap();
48968 wxPyEndAllowThreads(__tstate);
48969 if (PyErr_Occurred()) SWIG_fail;
48970 }
48971 resultobj = SWIG_From_int(static_cast< int >(result));
48972 return resultobj;
48973 fail:
48974 return NULL;
48975 }
48976
48977
48978 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48979 PyObject *obj;
48980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48981 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48982 return SWIG_Py_Void();
48983 }
48984
48985 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48986 return SWIG_Python_InitShadowInstance(args);
48987 }
48988
48989 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48990 PyObject *resultobj = 0;
48991 int arg1 = (int) 1 ;
48992 int arg2 = (int) 0 ;
48993 int arg3 = (int) 0 ;
48994 int arg4 = (int) 0 ;
48995 wxFlexGridSizer *result = 0 ;
48996 int val1 ;
48997 int ecode1 = 0 ;
48998 int val2 ;
48999 int ecode2 = 0 ;
49000 int val3 ;
49001 int ecode3 = 0 ;
49002 int val4 ;
49003 int ecode4 = 0 ;
49004 PyObject * obj0 = 0 ;
49005 PyObject * obj1 = 0 ;
49006 PyObject * obj2 = 0 ;
49007 PyObject * obj3 = 0 ;
49008 char * kwnames[] = {
49009 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49010 };
49011
49012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49013 if (obj0) {
49014 ecode1 = SWIG_AsVal_int(obj0, &val1);
49015 if (!SWIG_IsOK(ecode1)) {
49016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49017 }
49018 arg1 = static_cast< int >(val1);
49019 }
49020 if (obj1) {
49021 ecode2 = SWIG_AsVal_int(obj1, &val2);
49022 if (!SWIG_IsOK(ecode2)) {
49023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49024 }
49025 arg2 = static_cast< int >(val2);
49026 }
49027 if (obj2) {
49028 ecode3 = SWIG_AsVal_int(obj2, &val3);
49029 if (!SWIG_IsOK(ecode3)) {
49030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49031 }
49032 arg3 = static_cast< int >(val3);
49033 }
49034 if (obj3) {
49035 ecode4 = SWIG_AsVal_int(obj3, &val4);
49036 if (!SWIG_IsOK(ecode4)) {
49037 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49038 }
49039 arg4 = static_cast< int >(val4);
49040 }
49041 {
49042 PyThreadState* __tstate = wxPyBeginAllowThreads();
49043 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49044 wxPyEndAllowThreads(__tstate);
49045 if (PyErr_Occurred()) SWIG_fail;
49046 }
49047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49048 return resultobj;
49049 fail:
49050 return NULL;
49051 }
49052
49053
49054 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49055 PyObject *resultobj = 0;
49056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49057 size_t arg2 ;
49058 int arg3 = (int) 0 ;
49059 void *argp1 = 0 ;
49060 int res1 = 0 ;
49061 size_t val2 ;
49062 int ecode2 = 0 ;
49063 int val3 ;
49064 int ecode3 = 0 ;
49065 PyObject * obj0 = 0 ;
49066 PyObject * obj1 = 0 ;
49067 PyObject * obj2 = 0 ;
49068 char * kwnames[] = {
49069 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49070 };
49071
49072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49074 if (!SWIG_IsOK(res1)) {
49075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49076 }
49077 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49078 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49079 if (!SWIG_IsOK(ecode2)) {
49080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49081 }
49082 arg2 = static_cast< size_t >(val2);
49083 if (obj2) {
49084 ecode3 = SWIG_AsVal_int(obj2, &val3);
49085 if (!SWIG_IsOK(ecode3)) {
49086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49087 }
49088 arg3 = static_cast< int >(val3);
49089 }
49090 {
49091 PyThreadState* __tstate = wxPyBeginAllowThreads();
49092 (arg1)->AddGrowableRow(arg2,arg3);
49093 wxPyEndAllowThreads(__tstate);
49094 if (PyErr_Occurred()) SWIG_fail;
49095 }
49096 resultobj = SWIG_Py_Void();
49097 return resultobj;
49098 fail:
49099 return NULL;
49100 }
49101
49102
49103 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49104 PyObject *resultobj = 0;
49105 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49106 size_t arg2 ;
49107 void *argp1 = 0 ;
49108 int res1 = 0 ;
49109 size_t val2 ;
49110 int ecode2 = 0 ;
49111 PyObject * obj0 = 0 ;
49112 PyObject * obj1 = 0 ;
49113 char * kwnames[] = {
49114 (char *) "self",(char *) "idx", NULL
49115 };
49116
49117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49121 }
49122 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49123 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49124 if (!SWIG_IsOK(ecode2)) {
49125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49126 }
49127 arg2 = static_cast< size_t >(val2);
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 (arg1)->RemoveGrowableRow(arg2);
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_Py_Void();
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49142 PyObject *resultobj = 0;
49143 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49144 size_t arg2 ;
49145 int arg3 = (int) 0 ;
49146 void *argp1 = 0 ;
49147 int res1 = 0 ;
49148 size_t val2 ;
49149 int ecode2 = 0 ;
49150 int val3 ;
49151 int ecode3 = 0 ;
49152 PyObject * obj0 = 0 ;
49153 PyObject * obj1 = 0 ;
49154 PyObject * obj2 = 0 ;
49155 char * kwnames[] = {
49156 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49157 };
49158
49159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49161 if (!SWIG_IsOK(res1)) {
49162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49163 }
49164 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49165 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49166 if (!SWIG_IsOK(ecode2)) {
49167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49168 }
49169 arg2 = static_cast< size_t >(val2);
49170 if (obj2) {
49171 ecode3 = SWIG_AsVal_int(obj2, &val3);
49172 if (!SWIG_IsOK(ecode3)) {
49173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49174 }
49175 arg3 = static_cast< int >(val3);
49176 }
49177 {
49178 PyThreadState* __tstate = wxPyBeginAllowThreads();
49179 (arg1)->AddGrowableCol(arg2,arg3);
49180 wxPyEndAllowThreads(__tstate);
49181 if (PyErr_Occurred()) SWIG_fail;
49182 }
49183 resultobj = SWIG_Py_Void();
49184 return resultobj;
49185 fail:
49186 return NULL;
49187 }
49188
49189
49190 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49191 PyObject *resultobj = 0;
49192 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49193 size_t arg2 ;
49194 void *argp1 = 0 ;
49195 int res1 = 0 ;
49196 size_t val2 ;
49197 int ecode2 = 0 ;
49198 PyObject * obj0 = 0 ;
49199 PyObject * obj1 = 0 ;
49200 char * kwnames[] = {
49201 (char *) "self",(char *) "idx", NULL
49202 };
49203
49204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49208 }
49209 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49210 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49211 if (!SWIG_IsOK(ecode2)) {
49212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49213 }
49214 arg2 = static_cast< size_t >(val2);
49215 {
49216 PyThreadState* __tstate = wxPyBeginAllowThreads();
49217 (arg1)->RemoveGrowableCol(arg2);
49218 wxPyEndAllowThreads(__tstate);
49219 if (PyErr_Occurred()) SWIG_fail;
49220 }
49221 resultobj = SWIG_Py_Void();
49222 return resultobj;
49223 fail:
49224 return NULL;
49225 }
49226
49227
49228 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49229 PyObject *resultobj = 0;
49230 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49231 int arg2 ;
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 *) "self",(char *) "direction", NULL
49240 };
49241
49242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49244 if (!SWIG_IsOK(res1)) {
49245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49246 }
49247 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49248 ecode2 = SWIG_AsVal_int(obj1, &val2);
49249 if (!SWIG_IsOK(ecode2)) {
49250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49251 }
49252 arg2 = static_cast< int >(val2);
49253 {
49254 PyThreadState* __tstate = wxPyBeginAllowThreads();
49255 (arg1)->SetFlexibleDirection(arg2);
49256 wxPyEndAllowThreads(__tstate);
49257 if (PyErr_Occurred()) SWIG_fail;
49258 }
49259 resultobj = SWIG_Py_Void();
49260 return resultobj;
49261 fail:
49262 return NULL;
49263 }
49264
49265
49266 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49267 PyObject *resultobj = 0;
49268 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49269 int result;
49270 void *argp1 = 0 ;
49271 int res1 = 0 ;
49272 PyObject *swig_obj[1] ;
49273
49274 if (!args) SWIG_fail;
49275 swig_obj[0] = args;
49276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49277 if (!SWIG_IsOK(res1)) {
49278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49279 }
49280 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49281 {
49282 PyThreadState* __tstate = wxPyBeginAllowThreads();
49283 result = (int)(arg1)->GetFlexibleDirection();
49284 wxPyEndAllowThreads(__tstate);
49285 if (PyErr_Occurred()) SWIG_fail;
49286 }
49287 resultobj = SWIG_From_int(static_cast< int >(result));
49288 return resultobj;
49289 fail:
49290 return NULL;
49291 }
49292
49293
49294 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49295 PyObject *resultobj = 0;
49296 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49297 wxFlexSizerGrowMode arg2 ;
49298 void *argp1 = 0 ;
49299 int res1 = 0 ;
49300 int val2 ;
49301 int ecode2 = 0 ;
49302 PyObject * obj0 = 0 ;
49303 PyObject * obj1 = 0 ;
49304 char * kwnames[] = {
49305 (char *) "self",(char *) "mode", NULL
49306 };
49307
49308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49310 if (!SWIG_IsOK(res1)) {
49311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49312 }
49313 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49314 ecode2 = SWIG_AsVal_int(obj1, &val2);
49315 if (!SWIG_IsOK(ecode2)) {
49316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49317 }
49318 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49319 {
49320 PyThreadState* __tstate = wxPyBeginAllowThreads();
49321 (arg1)->SetNonFlexibleGrowMode(arg2);
49322 wxPyEndAllowThreads(__tstate);
49323 if (PyErr_Occurred()) SWIG_fail;
49324 }
49325 resultobj = SWIG_Py_Void();
49326 return resultobj;
49327 fail:
49328 return NULL;
49329 }
49330
49331
49332 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49333 PyObject *resultobj = 0;
49334 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49335 wxFlexSizerGrowMode result;
49336 void *argp1 = 0 ;
49337 int res1 = 0 ;
49338 PyObject *swig_obj[1] ;
49339
49340 if (!args) SWIG_fail;
49341 swig_obj[0] = args;
49342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49343 if (!SWIG_IsOK(res1)) {
49344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49345 }
49346 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49347 {
49348 PyThreadState* __tstate = wxPyBeginAllowThreads();
49349 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49350 wxPyEndAllowThreads(__tstate);
49351 if (PyErr_Occurred()) SWIG_fail;
49352 }
49353 resultobj = SWIG_From_int(static_cast< int >(result));
49354 return resultobj;
49355 fail:
49356 return NULL;
49357 }
49358
49359
49360 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49361 PyObject *resultobj = 0;
49362 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49363 wxArrayInt *result = 0 ;
49364 void *argp1 = 0 ;
49365 int res1 = 0 ;
49366 PyObject *swig_obj[1] ;
49367
49368 if (!args) SWIG_fail;
49369 swig_obj[0] = args;
49370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49371 if (!SWIG_IsOK(res1)) {
49372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49373 }
49374 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49375 {
49376 PyThreadState* __tstate = wxPyBeginAllowThreads();
49377 {
49378 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49379 result = (wxArrayInt *) &_result_ref;
49380 }
49381 wxPyEndAllowThreads(__tstate);
49382 if (PyErr_Occurred()) SWIG_fail;
49383 }
49384 {
49385 resultobj = PyList_New(0);
49386 size_t idx;
49387 for (idx = 0; idx < result->GetCount(); idx += 1) {
49388 PyObject* val = PyInt_FromLong( result->Item(idx) );
49389 PyList_Append(resultobj, val);
49390 Py_DECREF(val);
49391 }
49392 }
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49400 PyObject *resultobj = 0;
49401 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49402 wxArrayInt *result = 0 ;
49403 void *argp1 = 0 ;
49404 int res1 = 0 ;
49405 PyObject *swig_obj[1] ;
49406
49407 if (!args) SWIG_fail;
49408 swig_obj[0] = args;
49409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49410 if (!SWIG_IsOK(res1)) {
49411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49412 }
49413 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49414 {
49415 PyThreadState* __tstate = wxPyBeginAllowThreads();
49416 {
49417 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49418 result = (wxArrayInt *) &_result_ref;
49419 }
49420 wxPyEndAllowThreads(__tstate);
49421 if (PyErr_Occurred()) SWIG_fail;
49422 }
49423 {
49424 resultobj = PyList_New(0);
49425 size_t idx;
49426 for (idx = 0; idx < result->GetCount(); idx += 1) {
49427 PyObject* val = PyInt_FromLong( result->Item(idx) );
49428 PyList_Append(resultobj, val);
49429 Py_DECREF(val);
49430 }
49431 }
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49439 PyObject *obj;
49440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49441 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49442 return SWIG_Py_Void();
49443 }
49444
49445 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49446 return SWIG_Python_InitShadowInstance(args);
49447 }
49448
49449 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49450 PyObject *resultobj = 0;
49451 wxStdDialogButtonSizer *result = 0 ;
49452
49453 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49454 {
49455 PyThreadState* __tstate = wxPyBeginAllowThreads();
49456 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49457 wxPyEndAllowThreads(__tstate);
49458 if (PyErr_Occurred()) SWIG_fail;
49459 }
49460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49461 return resultobj;
49462 fail:
49463 return NULL;
49464 }
49465
49466
49467 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49468 PyObject *resultobj = 0;
49469 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49470 wxButton *arg2 = (wxButton *) 0 ;
49471 void *argp1 = 0 ;
49472 int res1 = 0 ;
49473 void *argp2 = 0 ;
49474 int res2 = 0 ;
49475 PyObject * obj0 = 0 ;
49476 PyObject * obj1 = 0 ;
49477 char * kwnames[] = {
49478 (char *) "self",(char *) "button", NULL
49479 };
49480
49481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49483 if (!SWIG_IsOK(res1)) {
49484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49485 }
49486 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49488 if (!SWIG_IsOK(res2)) {
49489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49490 }
49491 arg2 = reinterpret_cast< wxButton * >(argp2);
49492 {
49493 PyThreadState* __tstate = wxPyBeginAllowThreads();
49494 (arg1)->AddButton(arg2);
49495 wxPyEndAllowThreads(__tstate);
49496 if (PyErr_Occurred()) SWIG_fail;
49497 }
49498 resultobj = SWIG_Py_Void();
49499 return resultobj;
49500 fail:
49501 return NULL;
49502 }
49503
49504
49505 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49506 PyObject *resultobj = 0;
49507 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49508 void *argp1 = 0 ;
49509 int res1 = 0 ;
49510 PyObject *swig_obj[1] ;
49511
49512 if (!args) SWIG_fail;
49513 swig_obj[0] = args;
49514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49515 if (!SWIG_IsOK(res1)) {
49516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49517 }
49518 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49519 {
49520 PyThreadState* __tstate = wxPyBeginAllowThreads();
49521 (arg1)->Realize();
49522 wxPyEndAllowThreads(__tstate);
49523 if (PyErr_Occurred()) SWIG_fail;
49524 }
49525 resultobj = SWIG_Py_Void();
49526 return resultobj;
49527 fail:
49528 return NULL;
49529 }
49530
49531
49532 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49533 PyObject *resultobj = 0;
49534 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49535 wxButton *arg2 = (wxButton *) 0 ;
49536 void *argp1 = 0 ;
49537 int res1 = 0 ;
49538 void *argp2 = 0 ;
49539 int res2 = 0 ;
49540 PyObject * obj0 = 0 ;
49541 PyObject * obj1 = 0 ;
49542 char * kwnames[] = {
49543 (char *) "self",(char *) "button", NULL
49544 };
49545
49546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49550 }
49551 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49553 if (!SWIG_IsOK(res2)) {
49554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49555 }
49556 arg2 = reinterpret_cast< wxButton * >(argp2);
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 (arg1)->SetAffirmativeButton(arg2);
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_Py_Void();
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49571 PyObject *resultobj = 0;
49572 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49573 wxButton *arg2 = (wxButton *) 0 ;
49574 void *argp1 = 0 ;
49575 int res1 = 0 ;
49576 void *argp2 = 0 ;
49577 int res2 = 0 ;
49578 PyObject * obj0 = 0 ;
49579 PyObject * obj1 = 0 ;
49580 char * kwnames[] = {
49581 (char *) "self",(char *) "button", NULL
49582 };
49583
49584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49586 if (!SWIG_IsOK(res1)) {
49587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49588 }
49589 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49591 if (!SWIG_IsOK(res2)) {
49592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49593 }
49594 arg2 = reinterpret_cast< wxButton * >(argp2);
49595 {
49596 PyThreadState* __tstate = wxPyBeginAllowThreads();
49597 (arg1)->SetNegativeButton(arg2);
49598 wxPyEndAllowThreads(__tstate);
49599 if (PyErr_Occurred()) SWIG_fail;
49600 }
49601 resultobj = SWIG_Py_Void();
49602 return resultobj;
49603 fail:
49604 return NULL;
49605 }
49606
49607
49608 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49609 PyObject *resultobj = 0;
49610 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49611 wxButton *arg2 = (wxButton *) 0 ;
49612 void *argp1 = 0 ;
49613 int res1 = 0 ;
49614 void *argp2 = 0 ;
49615 int res2 = 0 ;
49616 PyObject * obj0 = 0 ;
49617 PyObject * obj1 = 0 ;
49618 char * kwnames[] = {
49619 (char *) "self",(char *) "button", NULL
49620 };
49621
49622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49624 if (!SWIG_IsOK(res1)) {
49625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49626 }
49627 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49629 if (!SWIG_IsOK(res2)) {
49630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49631 }
49632 arg2 = reinterpret_cast< wxButton * >(argp2);
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 (arg1)->SetCancelButton(arg2);
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_Py_Void();
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49647 PyObject *resultobj = 0;
49648 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49649 wxButton *result = 0 ;
49650 void *argp1 = 0 ;
49651 int res1 = 0 ;
49652 PyObject *swig_obj[1] ;
49653
49654 if (!args) SWIG_fail;
49655 swig_obj[0] = args;
49656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49657 if (!SWIG_IsOK(res1)) {
49658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49659 }
49660 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49661 {
49662 PyThreadState* __tstate = wxPyBeginAllowThreads();
49663 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49664 wxPyEndAllowThreads(__tstate);
49665 if (PyErr_Occurred()) SWIG_fail;
49666 }
49667 {
49668 resultobj = wxPyMake_wxObject(result, (bool)0);
49669 }
49670 return resultobj;
49671 fail:
49672 return NULL;
49673 }
49674
49675
49676 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49677 PyObject *resultobj = 0;
49678 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49679 wxButton *result = 0 ;
49680 void *argp1 = 0 ;
49681 int res1 = 0 ;
49682 PyObject *swig_obj[1] ;
49683
49684 if (!args) SWIG_fail;
49685 swig_obj[0] = args;
49686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49687 if (!SWIG_IsOK(res1)) {
49688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49689 }
49690 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49691 {
49692 PyThreadState* __tstate = wxPyBeginAllowThreads();
49693 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49694 wxPyEndAllowThreads(__tstate);
49695 if (PyErr_Occurred()) SWIG_fail;
49696 }
49697 {
49698 resultobj = wxPyMake_wxObject(result, (bool)0);
49699 }
49700 return resultobj;
49701 fail:
49702 return NULL;
49703 }
49704
49705
49706 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49707 PyObject *resultobj = 0;
49708 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49709 wxButton *result = 0 ;
49710 void *argp1 = 0 ;
49711 int res1 = 0 ;
49712 PyObject *swig_obj[1] ;
49713
49714 if (!args) SWIG_fail;
49715 swig_obj[0] = args;
49716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49717 if (!SWIG_IsOK(res1)) {
49718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49719 }
49720 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 {
49728 resultobj = wxPyMake_wxObject(result, (bool)0);
49729 }
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *resultobj = 0;
49738 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49739 wxButton *result = 0 ;
49740 void *argp1 = 0 ;
49741 int res1 = 0 ;
49742 PyObject *swig_obj[1] ;
49743
49744 if (!args) SWIG_fail;
49745 swig_obj[0] = args;
49746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49749 }
49750 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49751 {
49752 PyThreadState* __tstate = wxPyBeginAllowThreads();
49753 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49754 wxPyEndAllowThreads(__tstate);
49755 if (PyErr_Occurred()) SWIG_fail;
49756 }
49757 {
49758 resultobj = wxPyMake_wxObject(result, (bool)0);
49759 }
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *resultobj = 0;
49768 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49769 wxButton *result = 0 ;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject *swig_obj[1] ;
49773
49774 if (!args) SWIG_fail;
49775 swig_obj[0] = args;
49776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49779 }
49780 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 {
49788 resultobj = wxPyMake_wxObject(result, (bool)0);
49789 }
49790 return resultobj;
49791 fail:
49792 return NULL;
49793 }
49794
49795
49796 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49797 PyObject *obj;
49798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49799 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49800 return SWIG_Py_Void();
49801 }
49802
49803 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49804 return SWIG_Python_InitShadowInstance(args);
49805 }
49806
49807 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49808 PyObject *resultobj = 0;
49809 int arg1 = (int) 0 ;
49810 int arg2 = (int) 0 ;
49811 wxGBPosition *result = 0 ;
49812 int val1 ;
49813 int ecode1 = 0 ;
49814 int val2 ;
49815 int ecode2 = 0 ;
49816 PyObject * obj0 = 0 ;
49817 PyObject * obj1 = 0 ;
49818 char * kwnames[] = {
49819 (char *) "row",(char *) "col", NULL
49820 };
49821
49822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49823 if (obj0) {
49824 ecode1 = SWIG_AsVal_int(obj0, &val1);
49825 if (!SWIG_IsOK(ecode1)) {
49826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49827 }
49828 arg1 = static_cast< int >(val1);
49829 }
49830 if (obj1) {
49831 ecode2 = SWIG_AsVal_int(obj1, &val2);
49832 if (!SWIG_IsOK(ecode2)) {
49833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49834 }
49835 arg2 = static_cast< int >(val2);
49836 }
49837 {
49838 PyThreadState* __tstate = wxPyBeginAllowThreads();
49839 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49840 wxPyEndAllowThreads(__tstate);
49841 if (PyErr_Occurred()) SWIG_fail;
49842 }
49843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49844 return resultobj;
49845 fail:
49846 return NULL;
49847 }
49848
49849
49850 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49851 PyObject *resultobj = 0;
49852 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49853 void *argp1 = 0 ;
49854 int res1 = 0 ;
49855 PyObject *swig_obj[1] ;
49856
49857 if (!args) SWIG_fail;
49858 swig_obj[0] = args;
49859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49860 if (!SWIG_IsOK(res1)) {
49861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49862 }
49863 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 delete arg1;
49867
49868 wxPyEndAllowThreads(__tstate);
49869 if (PyErr_Occurred()) SWIG_fail;
49870 }
49871 resultobj = SWIG_Py_Void();
49872 return resultobj;
49873 fail:
49874 return NULL;
49875 }
49876
49877
49878 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49879 PyObject *resultobj = 0;
49880 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49881 int result;
49882 void *argp1 = 0 ;
49883 int res1 = 0 ;
49884 PyObject *swig_obj[1] ;
49885
49886 if (!args) SWIG_fail;
49887 swig_obj[0] = args;
49888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49889 if (!SWIG_IsOK(res1)) {
49890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49891 }
49892 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49893 {
49894 PyThreadState* __tstate = wxPyBeginAllowThreads();
49895 result = (int)((wxGBPosition const *)arg1)->GetRow();
49896 wxPyEndAllowThreads(__tstate);
49897 if (PyErr_Occurred()) SWIG_fail;
49898 }
49899 resultobj = SWIG_From_int(static_cast< int >(result));
49900 return resultobj;
49901 fail:
49902 return NULL;
49903 }
49904
49905
49906 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49907 PyObject *resultobj = 0;
49908 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49909 int result;
49910 void *argp1 = 0 ;
49911 int res1 = 0 ;
49912 PyObject *swig_obj[1] ;
49913
49914 if (!args) SWIG_fail;
49915 swig_obj[0] = args;
49916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49917 if (!SWIG_IsOK(res1)) {
49918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49919 }
49920 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49921 {
49922 PyThreadState* __tstate = wxPyBeginAllowThreads();
49923 result = (int)((wxGBPosition const *)arg1)->GetCol();
49924 wxPyEndAllowThreads(__tstate);
49925 if (PyErr_Occurred()) SWIG_fail;
49926 }
49927 resultobj = SWIG_From_int(static_cast< int >(result));
49928 return resultobj;
49929 fail:
49930 return NULL;
49931 }
49932
49933
49934 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49935 PyObject *resultobj = 0;
49936 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49937 int arg2 ;
49938 void *argp1 = 0 ;
49939 int res1 = 0 ;
49940 int val2 ;
49941 int ecode2 = 0 ;
49942 PyObject * obj0 = 0 ;
49943 PyObject * obj1 = 0 ;
49944 char * kwnames[] = {
49945 (char *) "self",(char *) "row", NULL
49946 };
49947
49948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49950 if (!SWIG_IsOK(res1)) {
49951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49952 }
49953 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49954 ecode2 = SWIG_AsVal_int(obj1, &val2);
49955 if (!SWIG_IsOK(ecode2)) {
49956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49957 }
49958 arg2 = static_cast< int >(val2);
49959 {
49960 PyThreadState* __tstate = wxPyBeginAllowThreads();
49961 (arg1)->SetRow(arg2);
49962 wxPyEndAllowThreads(__tstate);
49963 if (PyErr_Occurred()) SWIG_fail;
49964 }
49965 resultobj = SWIG_Py_Void();
49966 return resultobj;
49967 fail:
49968 return NULL;
49969 }
49970
49971
49972 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49973 PyObject *resultobj = 0;
49974 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49975 int arg2 ;
49976 void *argp1 = 0 ;
49977 int res1 = 0 ;
49978 int val2 ;
49979 int ecode2 = 0 ;
49980 PyObject * obj0 = 0 ;
49981 PyObject * obj1 = 0 ;
49982 char * kwnames[] = {
49983 (char *) "self",(char *) "col", NULL
49984 };
49985
49986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49988 if (!SWIG_IsOK(res1)) {
49989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49990 }
49991 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49992 ecode2 = SWIG_AsVal_int(obj1, &val2);
49993 if (!SWIG_IsOK(ecode2)) {
49994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49995 }
49996 arg2 = static_cast< int >(val2);
49997 {
49998 PyThreadState* __tstate = wxPyBeginAllowThreads();
49999 (arg1)->SetCol(arg2);
50000 wxPyEndAllowThreads(__tstate);
50001 if (PyErr_Occurred()) SWIG_fail;
50002 }
50003 resultobj = SWIG_Py_Void();
50004 return resultobj;
50005 fail:
50006 return NULL;
50007 }
50008
50009
50010 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50011 PyObject *resultobj = 0;
50012 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50013 PyObject *arg2 = (PyObject *) 0 ;
50014 bool result;
50015 void *argp1 = 0 ;
50016 int res1 = 0 ;
50017 PyObject * obj0 = 0 ;
50018 PyObject * obj1 = 0 ;
50019 char * kwnames[] = {
50020 (char *) "self",(char *) "other", NULL
50021 };
50022
50023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50025 if (!SWIG_IsOK(res1)) {
50026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50027 }
50028 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50029 arg2 = obj1;
50030 {
50031 result = (bool)wxGBPosition___eq__(arg1,arg2);
50032 if (PyErr_Occurred()) SWIG_fail;
50033 }
50034 {
50035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50036 }
50037 return resultobj;
50038 fail:
50039 return NULL;
50040 }
50041
50042
50043 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50044 PyObject *resultobj = 0;
50045 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50046 PyObject *arg2 = (PyObject *) 0 ;
50047 bool result;
50048 void *argp1 = 0 ;
50049 int res1 = 0 ;
50050 PyObject * obj0 = 0 ;
50051 PyObject * obj1 = 0 ;
50052 char * kwnames[] = {
50053 (char *) "self",(char *) "other", NULL
50054 };
50055
50056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50058 if (!SWIG_IsOK(res1)) {
50059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50060 }
50061 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50062 arg2 = obj1;
50063 {
50064 result = (bool)wxGBPosition___ne__(arg1,arg2);
50065 if (PyErr_Occurred()) SWIG_fail;
50066 }
50067 {
50068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50069 }
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50079 int arg2 = (int) 0 ;
50080 int arg3 = (int) 0 ;
50081 void *argp1 = 0 ;
50082 int res1 = 0 ;
50083 int val2 ;
50084 int ecode2 = 0 ;
50085 int val3 ;
50086 int ecode3 = 0 ;
50087 PyObject * obj0 = 0 ;
50088 PyObject * obj1 = 0 ;
50089 PyObject * obj2 = 0 ;
50090 char * kwnames[] = {
50091 (char *) "self",(char *) "row",(char *) "col", NULL
50092 };
50093
50094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50096 if (!SWIG_IsOK(res1)) {
50097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50098 }
50099 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50100 if (obj1) {
50101 ecode2 = SWIG_AsVal_int(obj1, &val2);
50102 if (!SWIG_IsOK(ecode2)) {
50103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50104 }
50105 arg2 = static_cast< int >(val2);
50106 }
50107 if (obj2) {
50108 ecode3 = SWIG_AsVal_int(obj2, &val3);
50109 if (!SWIG_IsOK(ecode3)) {
50110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50111 }
50112 arg3 = static_cast< int >(val3);
50113 }
50114 {
50115 PyThreadState* __tstate = wxPyBeginAllowThreads();
50116 wxGBPosition_Set(arg1,arg2,arg3);
50117 wxPyEndAllowThreads(__tstate);
50118 if (PyErr_Occurred()) SWIG_fail;
50119 }
50120 resultobj = SWIG_Py_Void();
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50128 PyObject *resultobj = 0;
50129 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50130 PyObject *result = 0 ;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 PyObject *swig_obj[1] ;
50134
50135 if (!args) SWIG_fail;
50136 swig_obj[0] = args;
50137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50138 if (!SWIG_IsOK(res1)) {
50139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50140 }
50141 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50142 {
50143 PyThreadState* __tstate = wxPyBeginAllowThreads();
50144 result = (PyObject *)wxGBPosition_Get(arg1);
50145 wxPyEndAllowThreads(__tstate);
50146 if (PyErr_Occurred()) SWIG_fail;
50147 }
50148 resultobj = result;
50149 return resultobj;
50150 fail:
50151 return NULL;
50152 }
50153
50154
50155 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50156 PyObject *obj;
50157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50158 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50159 return SWIG_Py_Void();
50160 }
50161
50162 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50163 return SWIG_Python_InitShadowInstance(args);
50164 }
50165
50166 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50167 PyObject *resultobj = 0;
50168 int arg1 = (int) 1 ;
50169 int arg2 = (int) 1 ;
50170 wxGBSpan *result = 0 ;
50171 int val1 ;
50172 int ecode1 = 0 ;
50173 int val2 ;
50174 int ecode2 = 0 ;
50175 PyObject * obj0 = 0 ;
50176 PyObject * obj1 = 0 ;
50177 char * kwnames[] = {
50178 (char *) "rowspan",(char *) "colspan", NULL
50179 };
50180
50181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50182 if (obj0) {
50183 ecode1 = SWIG_AsVal_int(obj0, &val1);
50184 if (!SWIG_IsOK(ecode1)) {
50185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50186 }
50187 arg1 = static_cast< int >(val1);
50188 }
50189 if (obj1) {
50190 ecode2 = SWIG_AsVal_int(obj1, &val2);
50191 if (!SWIG_IsOK(ecode2)) {
50192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50193 }
50194 arg2 = static_cast< int >(val2);
50195 }
50196 {
50197 PyThreadState* __tstate = wxPyBeginAllowThreads();
50198 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50199 wxPyEndAllowThreads(__tstate);
50200 if (PyErr_Occurred()) SWIG_fail;
50201 }
50202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50203 return resultobj;
50204 fail:
50205 return NULL;
50206 }
50207
50208
50209 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50210 PyObject *resultobj = 0;
50211 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50212 void *argp1 = 0 ;
50213 int res1 = 0 ;
50214 PyObject *swig_obj[1] ;
50215
50216 if (!args) SWIG_fail;
50217 swig_obj[0] = args;
50218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50219 if (!SWIG_IsOK(res1)) {
50220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50221 }
50222 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50223 {
50224 PyThreadState* __tstate = wxPyBeginAllowThreads();
50225 delete arg1;
50226
50227 wxPyEndAllowThreads(__tstate);
50228 if (PyErr_Occurred()) SWIG_fail;
50229 }
50230 resultobj = SWIG_Py_Void();
50231 return resultobj;
50232 fail:
50233 return NULL;
50234 }
50235
50236
50237 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50238 PyObject *resultobj = 0;
50239 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50240 int result;
50241 void *argp1 = 0 ;
50242 int res1 = 0 ;
50243 PyObject *swig_obj[1] ;
50244
50245 if (!args) SWIG_fail;
50246 swig_obj[0] = args;
50247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50248 if (!SWIG_IsOK(res1)) {
50249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50250 }
50251 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50252 {
50253 PyThreadState* __tstate = wxPyBeginAllowThreads();
50254 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50255 wxPyEndAllowThreads(__tstate);
50256 if (PyErr_Occurred()) SWIG_fail;
50257 }
50258 resultobj = SWIG_From_int(static_cast< int >(result));
50259 return resultobj;
50260 fail:
50261 return NULL;
50262 }
50263
50264
50265 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50266 PyObject *resultobj = 0;
50267 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50268 int result;
50269 void *argp1 = 0 ;
50270 int res1 = 0 ;
50271 PyObject *swig_obj[1] ;
50272
50273 if (!args) SWIG_fail;
50274 swig_obj[0] = args;
50275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50276 if (!SWIG_IsOK(res1)) {
50277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50278 }
50279 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 resultobj = SWIG_From_int(static_cast< int >(result));
50287 return resultobj;
50288 fail:
50289 return NULL;
50290 }
50291
50292
50293 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50294 PyObject *resultobj = 0;
50295 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50296 int arg2 ;
50297 void *argp1 = 0 ;
50298 int res1 = 0 ;
50299 int val2 ;
50300 int ecode2 = 0 ;
50301 PyObject * obj0 = 0 ;
50302 PyObject * obj1 = 0 ;
50303 char * kwnames[] = {
50304 (char *) "self",(char *) "rowspan", NULL
50305 };
50306
50307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50309 if (!SWIG_IsOK(res1)) {
50310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50311 }
50312 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50313 ecode2 = SWIG_AsVal_int(obj1, &val2);
50314 if (!SWIG_IsOK(ecode2)) {
50315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50316 }
50317 arg2 = static_cast< int >(val2);
50318 {
50319 PyThreadState* __tstate = wxPyBeginAllowThreads();
50320 (arg1)->SetRowspan(arg2);
50321 wxPyEndAllowThreads(__tstate);
50322 if (PyErr_Occurred()) SWIG_fail;
50323 }
50324 resultobj = SWIG_Py_Void();
50325 return resultobj;
50326 fail:
50327 return NULL;
50328 }
50329
50330
50331 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50332 PyObject *resultobj = 0;
50333 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50334 int arg2 ;
50335 void *argp1 = 0 ;
50336 int res1 = 0 ;
50337 int val2 ;
50338 int ecode2 = 0 ;
50339 PyObject * obj0 = 0 ;
50340 PyObject * obj1 = 0 ;
50341 char * kwnames[] = {
50342 (char *) "self",(char *) "colspan", NULL
50343 };
50344
50345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50347 if (!SWIG_IsOK(res1)) {
50348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50349 }
50350 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50351 ecode2 = SWIG_AsVal_int(obj1, &val2);
50352 if (!SWIG_IsOK(ecode2)) {
50353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50354 }
50355 arg2 = static_cast< int >(val2);
50356 {
50357 PyThreadState* __tstate = wxPyBeginAllowThreads();
50358 (arg1)->SetColspan(arg2);
50359 wxPyEndAllowThreads(__tstate);
50360 if (PyErr_Occurred()) SWIG_fail;
50361 }
50362 resultobj = SWIG_Py_Void();
50363 return resultobj;
50364 fail:
50365 return NULL;
50366 }
50367
50368
50369 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50370 PyObject *resultobj = 0;
50371 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50372 PyObject *arg2 = (PyObject *) 0 ;
50373 bool result;
50374 void *argp1 = 0 ;
50375 int res1 = 0 ;
50376 PyObject * obj0 = 0 ;
50377 PyObject * obj1 = 0 ;
50378 char * kwnames[] = {
50379 (char *) "self",(char *) "other", NULL
50380 };
50381
50382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50384 if (!SWIG_IsOK(res1)) {
50385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50386 }
50387 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50388 arg2 = obj1;
50389 {
50390 result = (bool)wxGBSpan___eq__(arg1,arg2);
50391 if (PyErr_Occurred()) SWIG_fail;
50392 }
50393 {
50394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50395 }
50396 return resultobj;
50397 fail:
50398 return NULL;
50399 }
50400
50401
50402 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50403 PyObject *resultobj = 0;
50404 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50405 PyObject *arg2 = (PyObject *) 0 ;
50406 bool result;
50407 void *argp1 = 0 ;
50408 int res1 = 0 ;
50409 PyObject * obj0 = 0 ;
50410 PyObject * obj1 = 0 ;
50411 char * kwnames[] = {
50412 (char *) "self",(char *) "other", NULL
50413 };
50414
50415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50417 if (!SWIG_IsOK(res1)) {
50418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50419 }
50420 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50421 arg2 = obj1;
50422 {
50423 result = (bool)wxGBSpan___ne__(arg1,arg2);
50424 if (PyErr_Occurred()) SWIG_fail;
50425 }
50426 {
50427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50428 }
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50436 PyObject *resultobj = 0;
50437 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50438 int arg2 = (int) 1 ;
50439 int arg3 = (int) 1 ;
50440 void *argp1 = 0 ;
50441 int res1 = 0 ;
50442 int val2 ;
50443 int ecode2 = 0 ;
50444 int val3 ;
50445 int ecode3 = 0 ;
50446 PyObject * obj0 = 0 ;
50447 PyObject * obj1 = 0 ;
50448 PyObject * obj2 = 0 ;
50449 char * kwnames[] = {
50450 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50451 };
50452
50453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50455 if (!SWIG_IsOK(res1)) {
50456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50457 }
50458 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50459 if (obj1) {
50460 ecode2 = SWIG_AsVal_int(obj1, &val2);
50461 if (!SWIG_IsOK(ecode2)) {
50462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50463 }
50464 arg2 = static_cast< int >(val2);
50465 }
50466 if (obj2) {
50467 ecode3 = SWIG_AsVal_int(obj2, &val3);
50468 if (!SWIG_IsOK(ecode3)) {
50469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50470 }
50471 arg3 = static_cast< int >(val3);
50472 }
50473 {
50474 PyThreadState* __tstate = wxPyBeginAllowThreads();
50475 wxGBSpan_Set(arg1,arg2,arg3);
50476 wxPyEndAllowThreads(__tstate);
50477 if (PyErr_Occurred()) SWIG_fail;
50478 }
50479 resultobj = SWIG_Py_Void();
50480 return resultobj;
50481 fail:
50482 return NULL;
50483 }
50484
50485
50486 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50487 PyObject *resultobj = 0;
50488 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50489 PyObject *result = 0 ;
50490 void *argp1 = 0 ;
50491 int res1 = 0 ;
50492 PyObject *swig_obj[1] ;
50493
50494 if (!args) SWIG_fail;
50495 swig_obj[0] = args;
50496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50497 if (!SWIG_IsOK(res1)) {
50498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50499 }
50500 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50501 {
50502 PyThreadState* __tstate = wxPyBeginAllowThreads();
50503 result = (PyObject *)wxGBSpan_Get(arg1);
50504 wxPyEndAllowThreads(__tstate);
50505 if (PyErr_Occurred()) SWIG_fail;
50506 }
50507 resultobj = result;
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50515 PyObject *obj;
50516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50517 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50518 return SWIG_Py_Void();
50519 }
50520
50521 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50522 return SWIG_Python_InitShadowInstance(args);
50523 }
50524
50525 SWIGINTERN int DefaultSpan_set(PyObject *) {
50526 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50527 return 1;
50528 }
50529
50530
50531 SWIGINTERN PyObject *DefaultSpan_get(void) {
50532 PyObject *pyobj = 0;
50533
50534 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50535 return pyobj;
50536 }
50537
50538
50539 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50540 PyObject *resultobj = 0;
50541 wxGBSizerItem *result = 0 ;
50542
50543 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50544 {
50545 PyThreadState* __tstate = wxPyBeginAllowThreads();
50546 result = (wxGBSizerItem *)new wxGBSizerItem();
50547 wxPyEndAllowThreads(__tstate);
50548 if (PyErr_Occurred()) SWIG_fail;
50549 }
50550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50551 return resultobj;
50552 fail:
50553 return NULL;
50554 }
50555
50556
50557 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50558 PyObject *resultobj = 0;
50559 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50560 void *argp1 = 0 ;
50561 int res1 = 0 ;
50562 PyObject *swig_obj[1] ;
50563
50564 if (!args) SWIG_fail;
50565 swig_obj[0] = args;
50566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50567 if (!SWIG_IsOK(res1)) {
50568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50569 }
50570 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50571 {
50572 PyThreadState* __tstate = wxPyBeginAllowThreads();
50573 delete arg1;
50574
50575 wxPyEndAllowThreads(__tstate);
50576 if (PyErr_Occurred()) SWIG_fail;
50577 }
50578 resultobj = SWIG_Py_Void();
50579 return resultobj;
50580 fail:
50581 return NULL;
50582 }
50583
50584
50585 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50586 PyObject *resultobj = 0;
50587 wxWindow *arg1 = (wxWindow *) 0 ;
50588 wxGBPosition *arg2 = 0 ;
50589 wxGBSpan *arg3 = 0 ;
50590 int arg4 ;
50591 int arg5 ;
50592 PyObject *arg6 = (PyObject *) NULL ;
50593 wxGBSizerItem *result = 0 ;
50594 void *argp1 = 0 ;
50595 int res1 = 0 ;
50596 wxGBPosition temp2 ;
50597 wxGBSpan temp3 ;
50598 int val4 ;
50599 int ecode4 = 0 ;
50600 int val5 ;
50601 int ecode5 = 0 ;
50602 PyObject * obj0 = 0 ;
50603 PyObject * obj1 = 0 ;
50604 PyObject * obj2 = 0 ;
50605 PyObject * obj3 = 0 ;
50606 PyObject * obj4 = 0 ;
50607 PyObject * obj5 = 0 ;
50608 char * kwnames[] = {
50609 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50610 };
50611
50612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50614 if (!SWIG_IsOK(res1)) {
50615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50616 }
50617 arg1 = reinterpret_cast< wxWindow * >(argp1);
50618 {
50619 arg2 = &temp2;
50620 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50621 }
50622 {
50623 arg3 = &temp3;
50624 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50625 }
50626 ecode4 = SWIG_AsVal_int(obj3, &val4);
50627 if (!SWIG_IsOK(ecode4)) {
50628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50629 }
50630 arg4 = static_cast< int >(val4);
50631 ecode5 = SWIG_AsVal_int(obj4, &val5);
50632 if (!SWIG_IsOK(ecode5)) {
50633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50634 }
50635 arg5 = static_cast< int >(val5);
50636 if (obj5) {
50637 arg6 = obj5;
50638 }
50639 {
50640 PyThreadState* __tstate = wxPyBeginAllowThreads();
50641 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50642 wxPyEndAllowThreads(__tstate);
50643 if (PyErr_Occurred()) SWIG_fail;
50644 }
50645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50646 return resultobj;
50647 fail:
50648 return NULL;
50649 }
50650
50651
50652 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50653 PyObject *resultobj = 0;
50654 wxSizer *arg1 = (wxSizer *) 0 ;
50655 wxGBPosition *arg2 = 0 ;
50656 wxGBSpan *arg3 = 0 ;
50657 int arg4 ;
50658 int arg5 ;
50659 PyObject *arg6 = (PyObject *) NULL ;
50660 wxGBSizerItem *result = 0 ;
50661 int res1 = 0 ;
50662 wxGBPosition temp2 ;
50663 wxGBSpan temp3 ;
50664 int val4 ;
50665 int ecode4 = 0 ;
50666 int val5 ;
50667 int ecode5 = 0 ;
50668 PyObject * obj0 = 0 ;
50669 PyObject * obj1 = 0 ;
50670 PyObject * obj2 = 0 ;
50671 PyObject * obj3 = 0 ;
50672 PyObject * obj4 = 0 ;
50673 PyObject * obj5 = 0 ;
50674 char * kwnames[] = {
50675 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50676 };
50677
50678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50679 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50680 if (!SWIG_IsOK(res1)) {
50681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50682 }
50683 {
50684 arg2 = &temp2;
50685 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50686 }
50687 {
50688 arg3 = &temp3;
50689 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50690 }
50691 ecode4 = SWIG_AsVal_int(obj3, &val4);
50692 if (!SWIG_IsOK(ecode4)) {
50693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50694 }
50695 arg4 = static_cast< int >(val4);
50696 ecode5 = SWIG_AsVal_int(obj4, &val5);
50697 if (!SWIG_IsOK(ecode5)) {
50698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50699 }
50700 arg5 = static_cast< int >(val5);
50701 if (obj5) {
50702 arg6 = obj5;
50703 }
50704 {
50705 PyThreadState* __tstate = wxPyBeginAllowThreads();
50706 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50707 wxPyEndAllowThreads(__tstate);
50708 if (PyErr_Occurred()) SWIG_fail;
50709 }
50710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50711 return resultobj;
50712 fail:
50713 return NULL;
50714 }
50715
50716
50717 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50718 PyObject *resultobj = 0;
50719 int arg1 ;
50720 int arg2 ;
50721 wxGBPosition *arg3 = 0 ;
50722 wxGBSpan *arg4 = 0 ;
50723 int arg5 ;
50724 int arg6 ;
50725 PyObject *arg7 = (PyObject *) NULL ;
50726 wxGBSizerItem *result = 0 ;
50727 int val1 ;
50728 int ecode1 = 0 ;
50729 int val2 ;
50730 int ecode2 = 0 ;
50731 wxGBPosition temp3 ;
50732 wxGBSpan temp4 ;
50733 int val5 ;
50734 int ecode5 = 0 ;
50735 int val6 ;
50736 int ecode6 = 0 ;
50737 PyObject * obj0 = 0 ;
50738 PyObject * obj1 = 0 ;
50739 PyObject * obj2 = 0 ;
50740 PyObject * obj3 = 0 ;
50741 PyObject * obj4 = 0 ;
50742 PyObject * obj5 = 0 ;
50743 PyObject * obj6 = 0 ;
50744 char * kwnames[] = {
50745 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50746 };
50747
50748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50749 ecode1 = SWIG_AsVal_int(obj0, &val1);
50750 if (!SWIG_IsOK(ecode1)) {
50751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50752 }
50753 arg1 = static_cast< int >(val1);
50754 ecode2 = SWIG_AsVal_int(obj1, &val2);
50755 if (!SWIG_IsOK(ecode2)) {
50756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50757 }
50758 arg2 = static_cast< int >(val2);
50759 {
50760 arg3 = &temp3;
50761 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50762 }
50763 {
50764 arg4 = &temp4;
50765 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50766 }
50767 ecode5 = SWIG_AsVal_int(obj4, &val5);
50768 if (!SWIG_IsOK(ecode5)) {
50769 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50770 }
50771 arg5 = static_cast< int >(val5);
50772 ecode6 = SWIG_AsVal_int(obj5, &val6);
50773 if (!SWIG_IsOK(ecode6)) {
50774 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50775 }
50776 arg6 = static_cast< int >(val6);
50777 if (obj6) {
50778 arg7 = obj6;
50779 }
50780 {
50781 PyThreadState* __tstate = wxPyBeginAllowThreads();
50782 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50783 wxPyEndAllowThreads(__tstate);
50784 if (PyErr_Occurred()) SWIG_fail;
50785 }
50786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50787 return resultobj;
50788 fail:
50789 return NULL;
50790 }
50791
50792
50793 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50794 PyObject *resultobj = 0;
50795 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50796 wxGBPosition result;
50797 void *argp1 = 0 ;
50798 int res1 = 0 ;
50799 PyObject *swig_obj[1] ;
50800
50801 if (!args) SWIG_fail;
50802 swig_obj[0] = args;
50803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50804 if (!SWIG_IsOK(res1)) {
50805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50806 }
50807 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50808 {
50809 PyThreadState* __tstate = wxPyBeginAllowThreads();
50810 result = ((wxGBSizerItem const *)arg1)->GetPos();
50811 wxPyEndAllowThreads(__tstate);
50812 if (PyErr_Occurred()) SWIG_fail;
50813 }
50814 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50815 return resultobj;
50816 fail:
50817 return NULL;
50818 }
50819
50820
50821 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50822 PyObject *resultobj = 0;
50823 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50824 wxGBSpan result;
50825 void *argp1 = 0 ;
50826 int res1 = 0 ;
50827 PyObject *swig_obj[1] ;
50828
50829 if (!args) SWIG_fail;
50830 swig_obj[0] = args;
50831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50832 if (!SWIG_IsOK(res1)) {
50833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50834 }
50835 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50836 {
50837 PyThreadState* __tstate = wxPyBeginAllowThreads();
50838 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50839 wxPyEndAllowThreads(__tstate);
50840 if (PyErr_Occurred()) SWIG_fail;
50841 }
50842 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50843 return resultobj;
50844 fail:
50845 return NULL;
50846 }
50847
50848
50849 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50850 PyObject *resultobj = 0;
50851 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50852 wxGBPosition *arg2 = 0 ;
50853 bool result;
50854 void *argp1 = 0 ;
50855 int res1 = 0 ;
50856 wxGBPosition temp2 ;
50857 PyObject * obj0 = 0 ;
50858 PyObject * obj1 = 0 ;
50859 char * kwnames[] = {
50860 (char *) "self",(char *) "pos", NULL
50861 };
50862
50863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50865 if (!SWIG_IsOK(res1)) {
50866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50867 }
50868 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50869 {
50870 arg2 = &temp2;
50871 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50872 }
50873 {
50874 PyThreadState* __tstate = wxPyBeginAllowThreads();
50875 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50876 wxPyEndAllowThreads(__tstate);
50877 if (PyErr_Occurred()) SWIG_fail;
50878 }
50879 {
50880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50881 }
50882 return resultobj;
50883 fail:
50884 return NULL;
50885 }
50886
50887
50888 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50889 PyObject *resultobj = 0;
50890 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50891 wxGBSpan *arg2 = 0 ;
50892 bool result;
50893 void *argp1 = 0 ;
50894 int res1 = 0 ;
50895 wxGBSpan temp2 ;
50896 PyObject * obj0 = 0 ;
50897 PyObject * obj1 = 0 ;
50898 char * kwnames[] = {
50899 (char *) "self",(char *) "span", NULL
50900 };
50901
50902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50904 if (!SWIG_IsOK(res1)) {
50905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50906 }
50907 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50908 {
50909 arg2 = &temp2;
50910 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50911 }
50912 {
50913 PyThreadState* __tstate = wxPyBeginAllowThreads();
50914 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50915 wxPyEndAllowThreads(__tstate);
50916 if (PyErr_Occurred()) SWIG_fail;
50917 }
50918 {
50919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50920 }
50921 return resultobj;
50922 fail:
50923 return NULL;
50924 }
50925
50926
50927 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50928 PyObject *resultobj = 0;
50929 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50930 wxGBSizerItem *arg2 = 0 ;
50931 bool result;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 void *argp2 = 0 ;
50935 int res2 = 0 ;
50936 PyObject * obj0 = 0 ;
50937 PyObject * obj1 = 0 ;
50938 char * kwnames[] = {
50939 (char *) "self",(char *) "other", NULL
50940 };
50941
50942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50944 if (!SWIG_IsOK(res1)) {
50945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50946 }
50947 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50949 if (!SWIG_IsOK(res2)) {
50950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50951 }
50952 if (!argp2) {
50953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50954 }
50955 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50956 {
50957 PyThreadState* __tstate = wxPyBeginAllowThreads();
50958 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50959 wxPyEndAllowThreads(__tstate);
50960 if (PyErr_Occurred()) SWIG_fail;
50961 }
50962 {
50963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50964 }
50965 return resultobj;
50966 fail:
50967 return NULL;
50968 }
50969
50970
50971 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50972 PyObject *resultobj = 0;
50973 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50974 wxGBPosition *arg2 = 0 ;
50975 wxGBSpan *arg3 = 0 ;
50976 bool result;
50977 void *argp1 = 0 ;
50978 int res1 = 0 ;
50979 wxGBPosition temp2 ;
50980 wxGBSpan temp3 ;
50981 PyObject * obj0 = 0 ;
50982 PyObject * obj1 = 0 ;
50983 PyObject * obj2 = 0 ;
50984 char * kwnames[] = {
50985 (char *) "self",(char *) "pos",(char *) "span", NULL
50986 };
50987
50988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50990 if (!SWIG_IsOK(res1)) {
50991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50992 }
50993 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50994 {
50995 arg2 = &temp2;
50996 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50997 }
50998 {
50999 arg3 = &temp3;
51000 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51001 }
51002 {
51003 PyThreadState* __tstate = wxPyBeginAllowThreads();
51004 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51005 wxPyEndAllowThreads(__tstate);
51006 if (PyErr_Occurred()) SWIG_fail;
51007 }
51008 {
51009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51010 }
51011 return resultobj;
51012 fail:
51013 return NULL;
51014 }
51015
51016
51017 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51018 PyObject *resultobj = 0;
51019 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51020 wxGBPosition result;
51021 void *argp1 = 0 ;
51022 int res1 = 0 ;
51023 PyObject *swig_obj[1] ;
51024
51025 if (!args) SWIG_fail;
51026 swig_obj[0] = args;
51027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51028 if (!SWIG_IsOK(res1)) {
51029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51030 }
51031 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51032 {
51033 PyThreadState* __tstate = wxPyBeginAllowThreads();
51034 result = wxGBSizerItem_GetEndPos(arg1);
51035 wxPyEndAllowThreads(__tstate);
51036 if (PyErr_Occurred()) SWIG_fail;
51037 }
51038 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51039 return resultobj;
51040 fail:
51041 return NULL;
51042 }
51043
51044
51045 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51046 PyObject *resultobj = 0;
51047 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51048 wxGridBagSizer *result = 0 ;
51049 void *argp1 = 0 ;
51050 int res1 = 0 ;
51051 PyObject *swig_obj[1] ;
51052
51053 if (!args) SWIG_fail;
51054 swig_obj[0] = args;
51055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51056 if (!SWIG_IsOK(res1)) {
51057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51058 }
51059 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51060 {
51061 PyThreadState* __tstate = wxPyBeginAllowThreads();
51062 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51063 wxPyEndAllowThreads(__tstate);
51064 if (PyErr_Occurred()) SWIG_fail;
51065 }
51066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51067 return resultobj;
51068 fail:
51069 return NULL;
51070 }
51071
51072
51073 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51074 PyObject *resultobj = 0;
51075 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51076 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51077 void *argp1 = 0 ;
51078 int res1 = 0 ;
51079 void *argp2 = 0 ;
51080 int res2 = 0 ;
51081 PyObject * obj0 = 0 ;
51082 PyObject * obj1 = 0 ;
51083 char * kwnames[] = {
51084 (char *) "self",(char *) "sizer", NULL
51085 };
51086
51087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51089 if (!SWIG_IsOK(res1)) {
51090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51091 }
51092 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51094 if (!SWIG_IsOK(res2)) {
51095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51096 }
51097 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51098 {
51099 PyThreadState* __tstate = wxPyBeginAllowThreads();
51100 (arg1)->SetGBSizer(arg2);
51101 wxPyEndAllowThreads(__tstate);
51102 if (PyErr_Occurred()) SWIG_fail;
51103 }
51104 resultobj = SWIG_Py_Void();
51105 return resultobj;
51106 fail:
51107 return NULL;
51108 }
51109
51110
51111 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51112 PyObject *obj;
51113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51114 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51115 return SWIG_Py_Void();
51116 }
51117
51118 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51119 return SWIG_Python_InitShadowInstance(args);
51120 }
51121
51122 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51123 PyObject *resultobj = 0;
51124 int arg1 = (int) 0 ;
51125 int arg2 = (int) 0 ;
51126 wxGridBagSizer *result = 0 ;
51127 int val1 ;
51128 int ecode1 = 0 ;
51129 int val2 ;
51130 int ecode2 = 0 ;
51131 PyObject * obj0 = 0 ;
51132 PyObject * obj1 = 0 ;
51133 char * kwnames[] = {
51134 (char *) "vgap",(char *) "hgap", NULL
51135 };
51136
51137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51138 if (obj0) {
51139 ecode1 = SWIG_AsVal_int(obj0, &val1);
51140 if (!SWIG_IsOK(ecode1)) {
51141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51142 }
51143 arg1 = static_cast< int >(val1);
51144 }
51145 if (obj1) {
51146 ecode2 = SWIG_AsVal_int(obj1, &val2);
51147 if (!SWIG_IsOK(ecode2)) {
51148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51149 }
51150 arg2 = static_cast< int >(val2);
51151 }
51152 {
51153 PyThreadState* __tstate = wxPyBeginAllowThreads();
51154 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51155 wxPyEndAllowThreads(__tstate);
51156 if (PyErr_Occurred()) SWIG_fail;
51157 }
51158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51159 return resultobj;
51160 fail:
51161 return NULL;
51162 }
51163
51164
51165 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51166 PyObject *resultobj = 0;
51167 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51168 PyObject *arg2 = (PyObject *) 0 ;
51169 wxGBPosition *arg3 = 0 ;
51170 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51171 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51172 int arg5 = (int) 0 ;
51173 int arg6 = (int) 0 ;
51174 PyObject *arg7 = (PyObject *) NULL ;
51175 wxGBSizerItem *result = 0 ;
51176 void *argp1 = 0 ;
51177 int res1 = 0 ;
51178 wxGBPosition temp3 ;
51179 wxGBSpan temp4 ;
51180 int val5 ;
51181 int ecode5 = 0 ;
51182 int val6 ;
51183 int ecode6 = 0 ;
51184 PyObject * obj0 = 0 ;
51185 PyObject * obj1 = 0 ;
51186 PyObject * obj2 = 0 ;
51187 PyObject * obj3 = 0 ;
51188 PyObject * obj4 = 0 ;
51189 PyObject * obj5 = 0 ;
51190 PyObject * obj6 = 0 ;
51191 char * kwnames[] = {
51192 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51193 };
51194
51195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51197 if (!SWIG_IsOK(res1)) {
51198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51199 }
51200 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51201 arg2 = obj1;
51202 {
51203 arg3 = &temp3;
51204 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51205 }
51206 if (obj3) {
51207 {
51208 arg4 = &temp4;
51209 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51210 }
51211 }
51212 if (obj4) {
51213 ecode5 = SWIG_AsVal_int(obj4, &val5);
51214 if (!SWIG_IsOK(ecode5)) {
51215 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51216 }
51217 arg5 = static_cast< int >(val5);
51218 }
51219 if (obj5) {
51220 ecode6 = SWIG_AsVal_int(obj5, &val6);
51221 if (!SWIG_IsOK(ecode6)) {
51222 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51223 }
51224 arg6 = static_cast< int >(val6);
51225 }
51226 if (obj6) {
51227 arg7 = obj6;
51228 }
51229 {
51230 PyThreadState* __tstate = wxPyBeginAllowThreads();
51231 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51232 wxPyEndAllowThreads(__tstate);
51233 if (PyErr_Occurred()) SWIG_fail;
51234 }
51235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51236 return resultobj;
51237 fail:
51238 return NULL;
51239 }
51240
51241
51242 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51243 PyObject *resultobj = 0;
51244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51245 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51246 wxGBSizerItem *result = 0 ;
51247 void *argp1 = 0 ;
51248 int res1 = 0 ;
51249 int res2 = 0 ;
51250 PyObject * obj0 = 0 ;
51251 PyObject * obj1 = 0 ;
51252 char * kwnames[] = {
51253 (char *) "self",(char *) "item", NULL
51254 };
51255
51256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51258 if (!SWIG_IsOK(res1)) {
51259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51260 }
51261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51262 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51263 if (!SWIG_IsOK(res2)) {
51264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51265 }
51266 {
51267 PyThreadState* __tstate = wxPyBeginAllowThreads();
51268 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51269 wxPyEndAllowThreads(__tstate);
51270 if (PyErr_Occurred()) SWIG_fail;
51271 }
51272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51273 return resultobj;
51274 fail:
51275 return NULL;
51276 }
51277
51278
51279 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51280 PyObject *resultobj = 0;
51281 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51282 int arg2 ;
51283 int arg3 ;
51284 wxSize result;
51285 void *argp1 = 0 ;
51286 int res1 = 0 ;
51287 int val2 ;
51288 int ecode2 = 0 ;
51289 int val3 ;
51290 int ecode3 = 0 ;
51291 PyObject * obj0 = 0 ;
51292 PyObject * obj1 = 0 ;
51293 PyObject * obj2 = 0 ;
51294 char * kwnames[] = {
51295 (char *) "self",(char *) "row",(char *) "col", NULL
51296 };
51297
51298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51302 }
51303 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51304 ecode2 = SWIG_AsVal_int(obj1, &val2);
51305 if (!SWIG_IsOK(ecode2)) {
51306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51307 }
51308 arg2 = static_cast< int >(val2);
51309 ecode3 = SWIG_AsVal_int(obj2, &val3);
51310 if (!SWIG_IsOK(ecode3)) {
51311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51312 }
51313 arg3 = static_cast< int >(val3);
51314 {
51315 PyThreadState* __tstate = wxPyBeginAllowThreads();
51316 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51317 wxPyEndAllowThreads(__tstate);
51318 if (PyErr_Occurred()) SWIG_fail;
51319 }
51320 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51321 return resultobj;
51322 fail:
51323 return NULL;
51324 }
51325
51326
51327 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51328 PyObject *resultobj = 0;
51329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51330 wxSize result;
51331 void *argp1 = 0 ;
51332 int res1 = 0 ;
51333 PyObject *swig_obj[1] ;
51334
51335 if (!args) SWIG_fail;
51336 swig_obj[0] = args;
51337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51338 if (!SWIG_IsOK(res1)) {
51339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51340 }
51341 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51342 {
51343 PyThreadState* __tstate = wxPyBeginAllowThreads();
51344 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51345 wxPyEndAllowThreads(__tstate);
51346 if (PyErr_Occurred()) SWIG_fail;
51347 }
51348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51349 return resultobj;
51350 fail:
51351 return NULL;
51352 }
51353
51354
51355 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51356 PyObject *resultobj = 0;
51357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51358 wxSize *arg2 = 0 ;
51359 void *argp1 = 0 ;
51360 int res1 = 0 ;
51361 wxSize temp2 ;
51362 PyObject * obj0 = 0 ;
51363 PyObject * obj1 = 0 ;
51364 char * kwnames[] = {
51365 (char *) "self",(char *) "sz", NULL
51366 };
51367
51368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51370 if (!SWIG_IsOK(res1)) {
51371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51372 }
51373 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51374 {
51375 arg2 = &temp2;
51376 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51377 }
51378 {
51379 PyThreadState* __tstate = wxPyBeginAllowThreads();
51380 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51381 wxPyEndAllowThreads(__tstate);
51382 if (PyErr_Occurred()) SWIG_fail;
51383 }
51384 resultobj = SWIG_Py_Void();
51385 return resultobj;
51386 fail:
51387 return NULL;
51388 }
51389
51390
51391 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51392 PyObject *resultobj = 0;
51393 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51394 wxWindow *arg2 = (wxWindow *) 0 ;
51395 wxGBPosition result;
51396 void *argp1 = 0 ;
51397 int res1 = 0 ;
51398 void *argp2 = 0 ;
51399 int res2 = 0 ;
51400
51401 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51403 if (!SWIG_IsOK(res1)) {
51404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51405 }
51406 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51407 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51408 if (!SWIG_IsOK(res2)) {
51409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51410 }
51411 arg2 = reinterpret_cast< wxWindow * >(argp2);
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 result = (arg1)->GetItemPosition(arg2);
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51419 return resultobj;
51420 fail:
51421 return NULL;
51422 }
51423
51424
51425 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51426 PyObject *resultobj = 0;
51427 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51428 wxSizer *arg2 = (wxSizer *) 0 ;
51429 wxGBPosition result;
51430 void *argp1 = 0 ;
51431 int res1 = 0 ;
51432 void *argp2 = 0 ;
51433 int res2 = 0 ;
51434
51435 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51437 if (!SWIG_IsOK(res1)) {
51438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51439 }
51440 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51441 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51442 if (!SWIG_IsOK(res2)) {
51443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51444 }
51445 arg2 = reinterpret_cast< wxSizer * >(argp2);
51446 {
51447 PyThreadState* __tstate = wxPyBeginAllowThreads();
51448 result = (arg1)->GetItemPosition(arg2);
51449 wxPyEndAllowThreads(__tstate);
51450 if (PyErr_Occurred()) SWIG_fail;
51451 }
51452 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51453 return resultobj;
51454 fail:
51455 return NULL;
51456 }
51457
51458
51459 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51460 PyObject *resultobj = 0;
51461 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51462 size_t arg2 ;
51463 wxGBPosition result;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 size_t val2 ;
51467 int ecode2 = 0 ;
51468
51469 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51471 if (!SWIG_IsOK(res1)) {
51472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51473 }
51474 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51475 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51476 if (!SWIG_IsOK(ecode2)) {
51477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51478 }
51479 arg2 = static_cast< size_t >(val2);
51480 {
51481 PyThreadState* __tstate = wxPyBeginAllowThreads();
51482 result = (arg1)->GetItemPosition(arg2);
51483 wxPyEndAllowThreads(__tstate);
51484 if (PyErr_Occurred()) SWIG_fail;
51485 }
51486 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51487 return resultobj;
51488 fail:
51489 return NULL;
51490 }
51491
51492
51493 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51494 int argc;
51495 PyObject *argv[3];
51496
51497 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51498 --argc;
51499 if (argc == 2) {
51500 int _v = 0;
51501 {
51502 void *vptr = 0;
51503 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51504 _v = SWIG_CheckState(res);
51505 }
51506 if (!_v) goto check_1;
51507 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51508 }
51509 check_1:
51510
51511 if (argc == 2) {
51512 int _v = 0;
51513 {
51514 void *vptr = 0;
51515 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51516 _v = SWIG_CheckState(res);
51517 }
51518 if (!_v) goto check_2;
51519 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51520 }
51521 check_2:
51522
51523 if (argc == 2) {
51524 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51525 }
51526
51527 fail:
51528 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51529 return NULL;
51530 }
51531
51532
51533 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51534 PyObject *resultobj = 0;
51535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51536 wxWindow *arg2 = (wxWindow *) 0 ;
51537 wxGBPosition *arg3 = 0 ;
51538 bool result;
51539 void *argp1 = 0 ;
51540 int res1 = 0 ;
51541 void *argp2 = 0 ;
51542 int res2 = 0 ;
51543 wxGBPosition temp3 ;
51544
51545 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51547 if (!SWIG_IsOK(res1)) {
51548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51549 }
51550 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51551 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51552 if (!SWIG_IsOK(res2)) {
51553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51554 }
51555 arg2 = reinterpret_cast< wxWindow * >(argp2);
51556 {
51557 arg3 = &temp3;
51558 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51559 }
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
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_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51576 PyObject *resultobj = 0;
51577 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51578 wxSizer *arg2 = (wxSizer *) 0 ;
51579 wxGBPosition *arg3 = 0 ;
51580 bool result;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 void *argp2 = 0 ;
51584 int res2 = 0 ;
51585 wxGBPosition temp3 ;
51586
51587 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51589 if (!SWIG_IsOK(res1)) {
51590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51591 }
51592 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51593 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51594 if (!SWIG_IsOK(res2)) {
51595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51596 }
51597 arg2 = reinterpret_cast< wxSizer * >(argp2);
51598 {
51599 arg3 = &temp3;
51600 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51601 }
51602 {
51603 PyThreadState* __tstate = wxPyBeginAllowThreads();
51604 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51605 wxPyEndAllowThreads(__tstate);
51606 if (PyErr_Occurred()) SWIG_fail;
51607 }
51608 {
51609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51610 }
51611 return resultobj;
51612 fail:
51613 return NULL;
51614 }
51615
51616
51617 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51618 PyObject *resultobj = 0;
51619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51620 size_t arg2 ;
51621 wxGBPosition *arg3 = 0 ;
51622 bool result;
51623 void *argp1 = 0 ;
51624 int res1 = 0 ;
51625 size_t val2 ;
51626 int ecode2 = 0 ;
51627 wxGBPosition temp3 ;
51628
51629 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51631 if (!SWIG_IsOK(res1)) {
51632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51633 }
51634 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51635 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51636 if (!SWIG_IsOK(ecode2)) {
51637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51638 }
51639 arg2 = static_cast< size_t >(val2);
51640 {
51641 arg3 = &temp3;
51642 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51643 }
51644 {
51645 PyThreadState* __tstate = wxPyBeginAllowThreads();
51646 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51647 wxPyEndAllowThreads(__tstate);
51648 if (PyErr_Occurred()) SWIG_fail;
51649 }
51650 {
51651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51652 }
51653 return resultobj;
51654 fail:
51655 return NULL;
51656 }
51657
51658
51659 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51660 int argc;
51661 PyObject *argv[4];
51662
51663 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51664 --argc;
51665 if (argc == 3) {
51666 int _v = 0;
51667 {
51668 void *vptr = 0;
51669 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51670 _v = SWIG_CheckState(res);
51671 }
51672 if (!_v) goto check_1;
51673 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51674 }
51675 check_1:
51676
51677 if (argc == 3) {
51678 int _v = 0;
51679 {
51680 void *vptr = 0;
51681 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51682 _v = SWIG_CheckState(res);
51683 }
51684 if (!_v) goto check_2;
51685 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51686 }
51687 check_2:
51688
51689 if (argc == 3) {
51690 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51691 }
51692
51693 fail:
51694 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51695 return NULL;
51696 }
51697
51698
51699 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51700 PyObject *resultobj = 0;
51701 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51702 wxWindow *arg2 = (wxWindow *) 0 ;
51703 wxGBSpan result;
51704 void *argp1 = 0 ;
51705 int res1 = 0 ;
51706 void *argp2 = 0 ;
51707 int res2 = 0 ;
51708
51709 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51711 if (!SWIG_IsOK(res1)) {
51712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51713 }
51714 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51715 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51716 if (!SWIG_IsOK(res2)) {
51717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51718 }
51719 arg2 = reinterpret_cast< wxWindow * >(argp2);
51720 {
51721 PyThreadState* __tstate = wxPyBeginAllowThreads();
51722 result = (arg1)->GetItemSpan(arg2);
51723 wxPyEndAllowThreads(__tstate);
51724 if (PyErr_Occurred()) SWIG_fail;
51725 }
51726 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51727 return resultobj;
51728 fail:
51729 return NULL;
51730 }
51731
51732
51733 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51734 PyObject *resultobj = 0;
51735 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51736 wxSizer *arg2 = (wxSizer *) 0 ;
51737 wxGBSpan result;
51738 void *argp1 = 0 ;
51739 int res1 = 0 ;
51740 void *argp2 = 0 ;
51741 int res2 = 0 ;
51742
51743 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51745 if (!SWIG_IsOK(res1)) {
51746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51747 }
51748 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51749 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51750 if (!SWIG_IsOK(res2)) {
51751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51752 }
51753 arg2 = reinterpret_cast< wxSizer * >(argp2);
51754 {
51755 PyThreadState* __tstate = wxPyBeginAllowThreads();
51756 result = (arg1)->GetItemSpan(arg2);
51757 wxPyEndAllowThreads(__tstate);
51758 if (PyErr_Occurred()) SWIG_fail;
51759 }
51760 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51761 return resultobj;
51762 fail:
51763 return NULL;
51764 }
51765
51766
51767 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51768 PyObject *resultobj = 0;
51769 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51770 size_t arg2 ;
51771 wxGBSpan result;
51772 void *argp1 = 0 ;
51773 int res1 = 0 ;
51774 size_t val2 ;
51775 int ecode2 = 0 ;
51776
51777 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51779 if (!SWIG_IsOK(res1)) {
51780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51781 }
51782 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51783 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51784 if (!SWIG_IsOK(ecode2)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51786 }
51787 arg2 = static_cast< size_t >(val2);
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 result = (arg1)->GetItemSpan(arg2);
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51802 int argc;
51803 PyObject *argv[3];
51804
51805 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51806 --argc;
51807 if (argc == 2) {
51808 int _v = 0;
51809 {
51810 void *vptr = 0;
51811 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51812 _v = SWIG_CheckState(res);
51813 }
51814 if (!_v) goto check_1;
51815 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51816 }
51817 check_1:
51818
51819 if (argc == 2) {
51820 int _v = 0;
51821 {
51822 void *vptr = 0;
51823 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51824 _v = SWIG_CheckState(res);
51825 }
51826 if (!_v) goto check_2;
51827 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51828 }
51829 check_2:
51830
51831 if (argc == 2) {
51832 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51833 }
51834
51835 fail:
51836 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51837 return NULL;
51838 }
51839
51840
51841 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51842 PyObject *resultobj = 0;
51843 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51844 wxWindow *arg2 = (wxWindow *) 0 ;
51845 wxGBSpan *arg3 = 0 ;
51846 bool result;
51847 void *argp1 = 0 ;
51848 int res1 = 0 ;
51849 void *argp2 = 0 ;
51850 int res2 = 0 ;
51851 wxGBSpan temp3 ;
51852
51853 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51855 if (!SWIG_IsOK(res1)) {
51856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51857 }
51858 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51859 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51860 if (!SWIG_IsOK(res2)) {
51861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51862 }
51863 arg2 = reinterpret_cast< wxWindow * >(argp2);
51864 {
51865 arg3 = &temp3;
51866 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51867 }
51868 {
51869 PyThreadState* __tstate = wxPyBeginAllowThreads();
51870 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51871 wxPyEndAllowThreads(__tstate);
51872 if (PyErr_Occurred()) SWIG_fail;
51873 }
51874 {
51875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51876 }
51877 return resultobj;
51878 fail:
51879 return NULL;
51880 }
51881
51882
51883 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51884 PyObject *resultobj = 0;
51885 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51886 wxSizer *arg2 = (wxSizer *) 0 ;
51887 wxGBSpan *arg3 = 0 ;
51888 bool result;
51889 void *argp1 = 0 ;
51890 int res1 = 0 ;
51891 void *argp2 = 0 ;
51892 int res2 = 0 ;
51893 wxGBSpan temp3 ;
51894
51895 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51897 if (!SWIG_IsOK(res1)) {
51898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51899 }
51900 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51901 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51902 if (!SWIG_IsOK(res2)) {
51903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51904 }
51905 arg2 = reinterpret_cast< wxSizer * >(argp2);
51906 {
51907 arg3 = &temp3;
51908 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51909 }
51910 {
51911 PyThreadState* __tstate = wxPyBeginAllowThreads();
51912 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51913 wxPyEndAllowThreads(__tstate);
51914 if (PyErr_Occurred()) SWIG_fail;
51915 }
51916 {
51917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51918 }
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51926 PyObject *resultobj = 0;
51927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51928 size_t arg2 ;
51929 wxGBSpan *arg3 = 0 ;
51930 bool result;
51931 void *argp1 = 0 ;
51932 int res1 = 0 ;
51933 size_t val2 ;
51934 int ecode2 = 0 ;
51935 wxGBSpan temp3 ;
51936
51937 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51939 if (!SWIG_IsOK(res1)) {
51940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51941 }
51942 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51943 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51944 if (!SWIG_IsOK(ecode2)) {
51945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51946 }
51947 arg2 = static_cast< size_t >(val2);
51948 {
51949 arg3 = &temp3;
51950 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51951 }
51952 {
51953 PyThreadState* __tstate = wxPyBeginAllowThreads();
51954 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51955 wxPyEndAllowThreads(__tstate);
51956 if (PyErr_Occurred()) SWIG_fail;
51957 }
51958 {
51959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51960 }
51961 return resultobj;
51962 fail:
51963 return NULL;
51964 }
51965
51966
51967 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51968 int argc;
51969 PyObject *argv[4];
51970
51971 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51972 --argc;
51973 if (argc == 3) {
51974 int _v = 0;
51975 {
51976 void *vptr = 0;
51977 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51978 _v = SWIG_CheckState(res);
51979 }
51980 if (!_v) goto check_1;
51981 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51982 }
51983 check_1:
51984
51985 if (argc == 3) {
51986 int _v = 0;
51987 {
51988 void *vptr = 0;
51989 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51990 _v = SWIG_CheckState(res);
51991 }
51992 if (!_v) goto check_2;
51993 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51994 }
51995 check_2:
51996
51997 if (argc == 3) {
51998 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51999 }
52000
52001 fail:
52002 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52003 return NULL;
52004 }
52005
52006
52007 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52008 PyObject *resultobj = 0;
52009 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52010 wxWindow *arg2 = (wxWindow *) 0 ;
52011 wxGBSizerItem *result = 0 ;
52012 void *argp1 = 0 ;
52013 int res1 = 0 ;
52014 void *argp2 = 0 ;
52015 int res2 = 0 ;
52016
52017 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52019 if (!SWIG_IsOK(res1)) {
52020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52021 }
52022 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52023 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52024 if (!SWIG_IsOK(res2)) {
52025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52026 }
52027 arg2 = reinterpret_cast< wxWindow * >(argp2);
52028 {
52029 PyThreadState* __tstate = wxPyBeginAllowThreads();
52030 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52031 wxPyEndAllowThreads(__tstate);
52032 if (PyErr_Occurred()) SWIG_fail;
52033 }
52034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52035 return resultobj;
52036 fail:
52037 return NULL;
52038 }
52039
52040
52041 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52042 PyObject *resultobj = 0;
52043 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52044 wxSizer *arg2 = (wxSizer *) 0 ;
52045 wxGBSizerItem *result = 0 ;
52046 void *argp1 = 0 ;
52047 int res1 = 0 ;
52048 void *argp2 = 0 ;
52049 int res2 = 0 ;
52050
52051 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52053 if (!SWIG_IsOK(res1)) {
52054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52055 }
52056 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52057 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52058 if (!SWIG_IsOK(res2)) {
52059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52060 }
52061 arg2 = reinterpret_cast< wxSizer * >(argp2);
52062 {
52063 PyThreadState* __tstate = wxPyBeginAllowThreads();
52064 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52065 wxPyEndAllowThreads(__tstate);
52066 if (PyErr_Occurred()) SWIG_fail;
52067 }
52068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52076 int argc;
52077 PyObject *argv[3];
52078
52079 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52080 --argc;
52081 if (argc == 2) {
52082 int _v = 0;
52083 {
52084 void *vptr = 0;
52085 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52086 _v = SWIG_CheckState(res);
52087 }
52088 if (!_v) goto check_1;
52089 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52090 }
52091 check_1:
52092
52093 if (argc == 2) {
52094 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52095 }
52096
52097 fail:
52098 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52099 return NULL;
52100 }
52101
52102
52103 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52104 PyObject *resultobj = 0;
52105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52106 wxGBPosition *arg2 = 0 ;
52107 wxGBSizerItem *result = 0 ;
52108 void *argp1 = 0 ;
52109 int res1 = 0 ;
52110 wxGBPosition temp2 ;
52111 PyObject * obj0 = 0 ;
52112 PyObject * obj1 = 0 ;
52113 char * kwnames[] = {
52114 (char *) "self",(char *) "pos", NULL
52115 };
52116
52117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52119 if (!SWIG_IsOK(res1)) {
52120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52121 }
52122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52123 {
52124 arg2 = &temp2;
52125 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52126 }
52127 {
52128 PyThreadState* __tstate = wxPyBeginAllowThreads();
52129 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52130 wxPyEndAllowThreads(__tstate);
52131 if (PyErr_Occurred()) SWIG_fail;
52132 }
52133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52134 return resultobj;
52135 fail:
52136 return NULL;
52137 }
52138
52139
52140 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52141 PyObject *resultobj = 0;
52142 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52143 wxPoint *arg2 = 0 ;
52144 wxGBSizerItem *result = 0 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 wxPoint temp2 ;
52148 PyObject * obj0 = 0 ;
52149 PyObject * obj1 = 0 ;
52150 char * kwnames[] = {
52151 (char *) "self",(char *) "pt", NULL
52152 };
52153
52154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52156 if (!SWIG_IsOK(res1)) {
52157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52158 }
52159 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52160 {
52161 arg2 = &temp2;
52162 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52163 }
52164 {
52165 PyThreadState* __tstate = wxPyBeginAllowThreads();
52166 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52167 wxPyEndAllowThreads(__tstate);
52168 if (PyErr_Occurred()) SWIG_fail;
52169 }
52170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52171 return resultobj;
52172 fail:
52173 return NULL;
52174 }
52175
52176
52177 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52178 PyObject *resultobj = 0;
52179 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52180 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52181 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52182 bool result;
52183 void *argp1 = 0 ;
52184 int res1 = 0 ;
52185 void *argp2 = 0 ;
52186 int res2 = 0 ;
52187 void *argp3 = 0 ;
52188 int res3 = 0 ;
52189 PyObject * obj0 = 0 ;
52190 PyObject * obj1 = 0 ;
52191 PyObject * obj2 = 0 ;
52192 char * kwnames[] = {
52193 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52194 };
52195
52196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52198 if (!SWIG_IsOK(res1)) {
52199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52200 }
52201 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52203 if (!SWIG_IsOK(res2)) {
52204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52205 }
52206 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52207 if (obj2) {
52208 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52209 if (!SWIG_IsOK(res3)) {
52210 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52211 }
52212 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52213 }
52214 {
52215 PyThreadState* __tstate = wxPyBeginAllowThreads();
52216 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52217 wxPyEndAllowThreads(__tstate);
52218 if (PyErr_Occurred()) SWIG_fail;
52219 }
52220 {
52221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52222 }
52223 return resultobj;
52224 fail:
52225 return NULL;
52226 }
52227
52228
52229 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52230 PyObject *resultobj = 0;
52231 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52232 wxGBPosition *arg2 = 0 ;
52233 wxGBSpan *arg3 = 0 ;
52234 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52235 bool result;
52236 void *argp1 = 0 ;
52237 int res1 = 0 ;
52238 wxGBPosition temp2 ;
52239 wxGBSpan temp3 ;
52240 void *argp4 = 0 ;
52241 int res4 = 0 ;
52242 PyObject * obj0 = 0 ;
52243 PyObject * obj1 = 0 ;
52244 PyObject * obj2 = 0 ;
52245 PyObject * obj3 = 0 ;
52246 char * kwnames[] = {
52247 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52248 };
52249
52250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52252 if (!SWIG_IsOK(res1)) {
52253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52254 }
52255 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52256 {
52257 arg2 = &temp2;
52258 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52259 }
52260 {
52261 arg3 = &temp3;
52262 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52263 }
52264 if (obj3) {
52265 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52266 if (!SWIG_IsOK(res4)) {
52267 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52268 }
52269 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52270 }
52271 {
52272 PyThreadState* __tstate = wxPyBeginAllowThreads();
52273 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52274 wxPyEndAllowThreads(__tstate);
52275 if (PyErr_Occurred()) SWIG_fail;
52276 }
52277 {
52278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52279 }
52280 return resultobj;
52281 fail:
52282 return NULL;
52283 }
52284
52285
52286 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52287 PyObject *obj;
52288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52289 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52290 return SWIG_Py_Void();
52291 }
52292
52293 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52294 return SWIG_Python_InitShadowInstance(args);
52295 }
52296
52297 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52298 PyObject *resultobj = 0;
52299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52300 wxRelationship arg2 ;
52301 wxWindow *arg3 = (wxWindow *) 0 ;
52302 wxEdge arg4 ;
52303 int arg5 = (int) 0 ;
52304 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52305 void *argp1 = 0 ;
52306 int res1 = 0 ;
52307 int val2 ;
52308 int ecode2 = 0 ;
52309 void *argp3 = 0 ;
52310 int res3 = 0 ;
52311 int val4 ;
52312 int ecode4 = 0 ;
52313 int val5 ;
52314 int ecode5 = 0 ;
52315 int val6 ;
52316 int ecode6 = 0 ;
52317 PyObject * obj0 = 0 ;
52318 PyObject * obj1 = 0 ;
52319 PyObject * obj2 = 0 ;
52320 PyObject * obj3 = 0 ;
52321 PyObject * obj4 = 0 ;
52322 PyObject * obj5 = 0 ;
52323 char * kwnames[] = {
52324 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52325 };
52326
52327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52331 }
52332 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52333 ecode2 = SWIG_AsVal_int(obj1, &val2);
52334 if (!SWIG_IsOK(ecode2)) {
52335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52336 }
52337 arg2 = static_cast< wxRelationship >(val2);
52338 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52339 if (!SWIG_IsOK(res3)) {
52340 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52341 }
52342 arg3 = reinterpret_cast< wxWindow * >(argp3);
52343 ecode4 = SWIG_AsVal_int(obj3, &val4);
52344 if (!SWIG_IsOK(ecode4)) {
52345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52346 }
52347 arg4 = static_cast< wxEdge >(val4);
52348 if (obj4) {
52349 ecode5 = SWIG_AsVal_int(obj4, &val5);
52350 if (!SWIG_IsOK(ecode5)) {
52351 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52352 }
52353 arg5 = static_cast< int >(val5);
52354 }
52355 if (obj5) {
52356 ecode6 = SWIG_AsVal_int(obj5, &val6);
52357 if (!SWIG_IsOK(ecode6)) {
52358 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52359 }
52360 arg6 = static_cast< int >(val6);
52361 }
52362 {
52363 PyThreadState* __tstate = wxPyBeginAllowThreads();
52364 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52365 wxPyEndAllowThreads(__tstate);
52366 if (PyErr_Occurred()) SWIG_fail;
52367 }
52368 resultobj = SWIG_Py_Void();
52369 return resultobj;
52370 fail:
52371 return NULL;
52372 }
52373
52374
52375 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52376 PyObject *resultobj = 0;
52377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52378 wxWindow *arg2 = (wxWindow *) 0 ;
52379 int arg3 = (int) 0 ;
52380 void *argp1 = 0 ;
52381 int res1 = 0 ;
52382 void *argp2 = 0 ;
52383 int res2 = 0 ;
52384 int val3 ;
52385 int ecode3 = 0 ;
52386 PyObject * obj0 = 0 ;
52387 PyObject * obj1 = 0 ;
52388 PyObject * obj2 = 0 ;
52389 char * kwnames[] = {
52390 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52391 };
52392
52393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52395 if (!SWIG_IsOK(res1)) {
52396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52397 }
52398 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52400 if (!SWIG_IsOK(res2)) {
52401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52402 }
52403 arg2 = reinterpret_cast< wxWindow * >(argp2);
52404 if (obj2) {
52405 ecode3 = SWIG_AsVal_int(obj2, &val3);
52406 if (!SWIG_IsOK(ecode3)) {
52407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52408 }
52409 arg3 = static_cast< int >(val3);
52410 }
52411 {
52412 PyThreadState* __tstate = wxPyBeginAllowThreads();
52413 (arg1)->LeftOf(arg2,arg3);
52414 wxPyEndAllowThreads(__tstate);
52415 if (PyErr_Occurred()) SWIG_fail;
52416 }
52417 resultobj = SWIG_Py_Void();
52418 return resultobj;
52419 fail:
52420 return NULL;
52421 }
52422
52423
52424 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52425 PyObject *resultobj = 0;
52426 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52427 wxWindow *arg2 = (wxWindow *) 0 ;
52428 int arg3 = (int) 0 ;
52429 void *argp1 = 0 ;
52430 int res1 = 0 ;
52431 void *argp2 = 0 ;
52432 int res2 = 0 ;
52433 int val3 ;
52434 int ecode3 = 0 ;
52435 PyObject * obj0 = 0 ;
52436 PyObject * obj1 = 0 ;
52437 PyObject * obj2 = 0 ;
52438 char * kwnames[] = {
52439 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52440 };
52441
52442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52444 if (!SWIG_IsOK(res1)) {
52445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52446 }
52447 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52449 if (!SWIG_IsOK(res2)) {
52450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52451 }
52452 arg2 = reinterpret_cast< wxWindow * >(argp2);
52453 if (obj2) {
52454 ecode3 = SWIG_AsVal_int(obj2, &val3);
52455 if (!SWIG_IsOK(ecode3)) {
52456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52457 }
52458 arg3 = static_cast< int >(val3);
52459 }
52460 {
52461 PyThreadState* __tstate = wxPyBeginAllowThreads();
52462 (arg1)->RightOf(arg2,arg3);
52463 wxPyEndAllowThreads(__tstate);
52464 if (PyErr_Occurred()) SWIG_fail;
52465 }
52466 resultobj = SWIG_Py_Void();
52467 return resultobj;
52468 fail:
52469 return NULL;
52470 }
52471
52472
52473 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52474 PyObject *resultobj = 0;
52475 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52476 wxWindow *arg2 = (wxWindow *) 0 ;
52477 int arg3 = (int) 0 ;
52478 void *argp1 = 0 ;
52479 int res1 = 0 ;
52480 void *argp2 = 0 ;
52481 int res2 = 0 ;
52482 int val3 ;
52483 int ecode3 = 0 ;
52484 PyObject * obj0 = 0 ;
52485 PyObject * obj1 = 0 ;
52486 PyObject * obj2 = 0 ;
52487 char * kwnames[] = {
52488 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52489 };
52490
52491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52495 }
52496 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52498 if (!SWIG_IsOK(res2)) {
52499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52500 }
52501 arg2 = reinterpret_cast< wxWindow * >(argp2);
52502 if (obj2) {
52503 ecode3 = SWIG_AsVal_int(obj2, &val3);
52504 if (!SWIG_IsOK(ecode3)) {
52505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52506 }
52507 arg3 = static_cast< int >(val3);
52508 }
52509 {
52510 PyThreadState* __tstate = wxPyBeginAllowThreads();
52511 (arg1)->Above(arg2,arg3);
52512 wxPyEndAllowThreads(__tstate);
52513 if (PyErr_Occurred()) SWIG_fail;
52514 }
52515 resultobj = SWIG_Py_Void();
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52523 PyObject *resultobj = 0;
52524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52525 wxWindow *arg2 = (wxWindow *) 0 ;
52526 int arg3 = (int) 0 ;
52527 void *argp1 = 0 ;
52528 int res1 = 0 ;
52529 void *argp2 = 0 ;
52530 int res2 = 0 ;
52531 int val3 ;
52532 int ecode3 = 0 ;
52533 PyObject * obj0 = 0 ;
52534 PyObject * obj1 = 0 ;
52535 PyObject * obj2 = 0 ;
52536 char * kwnames[] = {
52537 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52538 };
52539
52540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52542 if (!SWIG_IsOK(res1)) {
52543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52544 }
52545 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52547 if (!SWIG_IsOK(res2)) {
52548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52549 }
52550 arg2 = reinterpret_cast< wxWindow * >(argp2);
52551 if (obj2) {
52552 ecode3 = SWIG_AsVal_int(obj2, &val3);
52553 if (!SWIG_IsOK(ecode3)) {
52554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52555 }
52556 arg3 = static_cast< int >(val3);
52557 }
52558 {
52559 PyThreadState* __tstate = wxPyBeginAllowThreads();
52560 (arg1)->Below(arg2,arg3);
52561 wxPyEndAllowThreads(__tstate);
52562 if (PyErr_Occurred()) SWIG_fail;
52563 }
52564 resultobj = SWIG_Py_Void();
52565 return resultobj;
52566 fail:
52567 return NULL;
52568 }
52569
52570
52571 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52572 PyObject *resultobj = 0;
52573 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52574 wxWindow *arg2 = (wxWindow *) 0 ;
52575 wxEdge arg3 ;
52576 int arg4 = (int) 0 ;
52577 void *argp1 = 0 ;
52578 int res1 = 0 ;
52579 void *argp2 = 0 ;
52580 int res2 = 0 ;
52581 int val3 ;
52582 int ecode3 = 0 ;
52583 int val4 ;
52584 int ecode4 = 0 ;
52585 PyObject * obj0 = 0 ;
52586 PyObject * obj1 = 0 ;
52587 PyObject * obj2 = 0 ;
52588 PyObject * obj3 = 0 ;
52589 char * kwnames[] = {
52590 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52591 };
52592
52593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52595 if (!SWIG_IsOK(res1)) {
52596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52597 }
52598 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52600 if (!SWIG_IsOK(res2)) {
52601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52602 }
52603 arg2 = reinterpret_cast< wxWindow * >(argp2);
52604 ecode3 = SWIG_AsVal_int(obj2, &val3);
52605 if (!SWIG_IsOK(ecode3)) {
52606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52607 }
52608 arg3 = static_cast< wxEdge >(val3);
52609 if (obj3) {
52610 ecode4 = SWIG_AsVal_int(obj3, &val4);
52611 if (!SWIG_IsOK(ecode4)) {
52612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52613 }
52614 arg4 = static_cast< int >(val4);
52615 }
52616 {
52617 PyThreadState* __tstate = wxPyBeginAllowThreads();
52618 (arg1)->SameAs(arg2,arg3,arg4);
52619 wxPyEndAllowThreads(__tstate);
52620 if (PyErr_Occurred()) SWIG_fail;
52621 }
52622 resultobj = SWIG_Py_Void();
52623 return resultobj;
52624 fail:
52625 return NULL;
52626 }
52627
52628
52629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52630 PyObject *resultobj = 0;
52631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52632 wxWindow *arg2 = (wxWindow *) 0 ;
52633 wxEdge arg3 ;
52634 int arg4 ;
52635 void *argp1 = 0 ;
52636 int res1 = 0 ;
52637 void *argp2 = 0 ;
52638 int res2 = 0 ;
52639 int val3 ;
52640 int ecode3 = 0 ;
52641 int val4 ;
52642 int ecode4 = 0 ;
52643 PyObject * obj0 = 0 ;
52644 PyObject * obj1 = 0 ;
52645 PyObject * obj2 = 0 ;
52646 PyObject * obj3 = 0 ;
52647 char * kwnames[] = {
52648 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52649 };
52650
52651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52653 if (!SWIG_IsOK(res1)) {
52654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52655 }
52656 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52658 if (!SWIG_IsOK(res2)) {
52659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52660 }
52661 arg2 = reinterpret_cast< wxWindow * >(argp2);
52662 ecode3 = SWIG_AsVal_int(obj2, &val3);
52663 if (!SWIG_IsOK(ecode3)) {
52664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52665 }
52666 arg3 = static_cast< wxEdge >(val3);
52667 ecode4 = SWIG_AsVal_int(obj3, &val4);
52668 if (!SWIG_IsOK(ecode4)) {
52669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52670 }
52671 arg4 = static_cast< int >(val4);
52672 {
52673 PyThreadState* __tstate = wxPyBeginAllowThreads();
52674 (arg1)->PercentOf(arg2,arg3,arg4);
52675 wxPyEndAllowThreads(__tstate);
52676 if (PyErr_Occurred()) SWIG_fail;
52677 }
52678 resultobj = SWIG_Py_Void();
52679 return resultobj;
52680 fail:
52681 return NULL;
52682 }
52683
52684
52685 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52686 PyObject *resultobj = 0;
52687 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52688 int arg2 ;
52689 void *argp1 = 0 ;
52690 int res1 = 0 ;
52691 int val2 ;
52692 int ecode2 = 0 ;
52693 PyObject * obj0 = 0 ;
52694 PyObject * obj1 = 0 ;
52695 char * kwnames[] = {
52696 (char *) "self",(char *) "val", NULL
52697 };
52698
52699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52701 if (!SWIG_IsOK(res1)) {
52702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52703 }
52704 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52705 ecode2 = SWIG_AsVal_int(obj1, &val2);
52706 if (!SWIG_IsOK(ecode2)) {
52707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52708 }
52709 arg2 = static_cast< int >(val2);
52710 {
52711 PyThreadState* __tstate = wxPyBeginAllowThreads();
52712 (arg1)->Absolute(arg2);
52713 wxPyEndAllowThreads(__tstate);
52714 if (PyErr_Occurred()) SWIG_fail;
52715 }
52716 resultobj = SWIG_Py_Void();
52717 return resultobj;
52718 fail:
52719 return NULL;
52720 }
52721
52722
52723 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52724 PyObject *resultobj = 0;
52725 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52726 void *argp1 = 0 ;
52727 int res1 = 0 ;
52728 PyObject *swig_obj[1] ;
52729
52730 if (!args) SWIG_fail;
52731 swig_obj[0] = args;
52732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52733 if (!SWIG_IsOK(res1)) {
52734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52735 }
52736 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52737 {
52738 PyThreadState* __tstate = wxPyBeginAllowThreads();
52739 (arg1)->Unconstrained();
52740 wxPyEndAllowThreads(__tstate);
52741 if (PyErr_Occurred()) SWIG_fail;
52742 }
52743 resultobj = SWIG_Py_Void();
52744 return resultobj;
52745 fail:
52746 return NULL;
52747 }
52748
52749
52750 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52751 PyObject *resultobj = 0;
52752 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52753 void *argp1 = 0 ;
52754 int res1 = 0 ;
52755 PyObject *swig_obj[1] ;
52756
52757 if (!args) SWIG_fail;
52758 swig_obj[0] = args;
52759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52760 if (!SWIG_IsOK(res1)) {
52761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52762 }
52763 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52764 {
52765 PyThreadState* __tstate = wxPyBeginAllowThreads();
52766 (arg1)->AsIs();
52767 wxPyEndAllowThreads(__tstate);
52768 if (PyErr_Occurred()) SWIG_fail;
52769 }
52770 resultobj = SWIG_Py_Void();
52771 return resultobj;
52772 fail:
52773 return NULL;
52774 }
52775
52776
52777 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52778 PyObject *resultobj = 0;
52779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52780 wxWindow *result = 0 ;
52781 void *argp1 = 0 ;
52782 int res1 = 0 ;
52783 PyObject *swig_obj[1] ;
52784
52785 if (!args) SWIG_fail;
52786 swig_obj[0] = args;
52787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52788 if (!SWIG_IsOK(res1)) {
52789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52790 }
52791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52792 {
52793 PyThreadState* __tstate = wxPyBeginAllowThreads();
52794 result = (wxWindow *)(arg1)->GetOtherWindow();
52795 wxPyEndAllowThreads(__tstate);
52796 if (PyErr_Occurred()) SWIG_fail;
52797 }
52798 {
52799 resultobj = wxPyMake_wxObject(result, 0);
52800 }
52801 return resultobj;
52802 fail:
52803 return NULL;
52804 }
52805
52806
52807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52808 PyObject *resultobj = 0;
52809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52810 wxEdge result;
52811 void *argp1 = 0 ;
52812 int res1 = 0 ;
52813 PyObject *swig_obj[1] ;
52814
52815 if (!args) SWIG_fail;
52816 swig_obj[0] = args;
52817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52818 if (!SWIG_IsOK(res1)) {
52819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52820 }
52821 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52822 {
52823 PyThreadState* __tstate = wxPyBeginAllowThreads();
52824 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52825 wxPyEndAllowThreads(__tstate);
52826 if (PyErr_Occurred()) SWIG_fail;
52827 }
52828 resultobj = SWIG_From_int(static_cast< int >(result));
52829 return resultobj;
52830 fail:
52831 return NULL;
52832 }
52833
52834
52835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52836 PyObject *resultobj = 0;
52837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52838 wxEdge arg2 ;
52839 void *argp1 = 0 ;
52840 int res1 = 0 ;
52841 int val2 ;
52842 int ecode2 = 0 ;
52843 PyObject * obj0 = 0 ;
52844 PyObject * obj1 = 0 ;
52845 char * kwnames[] = {
52846 (char *) "self",(char *) "which", NULL
52847 };
52848
52849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52851 if (!SWIG_IsOK(res1)) {
52852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52853 }
52854 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52855 ecode2 = SWIG_AsVal_int(obj1, &val2);
52856 if (!SWIG_IsOK(ecode2)) {
52857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52858 }
52859 arg2 = static_cast< wxEdge >(val2);
52860 {
52861 PyThreadState* __tstate = wxPyBeginAllowThreads();
52862 (arg1)->SetEdge(arg2);
52863 wxPyEndAllowThreads(__tstate);
52864 if (PyErr_Occurred()) SWIG_fail;
52865 }
52866 resultobj = SWIG_Py_Void();
52867 return resultobj;
52868 fail:
52869 return NULL;
52870 }
52871
52872
52873 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52874 PyObject *resultobj = 0;
52875 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52876 int arg2 ;
52877 void *argp1 = 0 ;
52878 int res1 = 0 ;
52879 int val2 ;
52880 int ecode2 = 0 ;
52881 PyObject * obj0 = 0 ;
52882 PyObject * obj1 = 0 ;
52883 char * kwnames[] = {
52884 (char *) "self",(char *) "v", NULL
52885 };
52886
52887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52889 if (!SWIG_IsOK(res1)) {
52890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52891 }
52892 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52893 ecode2 = SWIG_AsVal_int(obj1, &val2);
52894 if (!SWIG_IsOK(ecode2)) {
52895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52896 }
52897 arg2 = static_cast< int >(val2);
52898 {
52899 PyThreadState* __tstate = wxPyBeginAllowThreads();
52900 (arg1)->SetValue(arg2);
52901 wxPyEndAllowThreads(__tstate);
52902 if (PyErr_Occurred()) SWIG_fail;
52903 }
52904 resultobj = SWIG_Py_Void();
52905 return resultobj;
52906 fail:
52907 return NULL;
52908 }
52909
52910
52911 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52912 PyObject *resultobj = 0;
52913 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52914 int result;
52915 void *argp1 = 0 ;
52916 int res1 = 0 ;
52917 PyObject *swig_obj[1] ;
52918
52919 if (!args) SWIG_fail;
52920 swig_obj[0] = args;
52921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52922 if (!SWIG_IsOK(res1)) {
52923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52924 }
52925 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52926 {
52927 PyThreadState* __tstate = wxPyBeginAllowThreads();
52928 result = (int)(arg1)->GetMargin();
52929 wxPyEndAllowThreads(__tstate);
52930 if (PyErr_Occurred()) SWIG_fail;
52931 }
52932 resultobj = SWIG_From_int(static_cast< int >(result));
52933 return resultobj;
52934 fail:
52935 return NULL;
52936 }
52937
52938
52939 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52940 PyObject *resultobj = 0;
52941 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52942 int arg2 ;
52943 void *argp1 = 0 ;
52944 int res1 = 0 ;
52945 int val2 ;
52946 int ecode2 = 0 ;
52947 PyObject * obj0 = 0 ;
52948 PyObject * obj1 = 0 ;
52949 char * kwnames[] = {
52950 (char *) "self",(char *) "m", NULL
52951 };
52952
52953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52955 if (!SWIG_IsOK(res1)) {
52956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52957 }
52958 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52959 ecode2 = SWIG_AsVal_int(obj1, &val2);
52960 if (!SWIG_IsOK(ecode2)) {
52961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52962 }
52963 arg2 = static_cast< int >(val2);
52964 {
52965 PyThreadState* __tstate = wxPyBeginAllowThreads();
52966 (arg1)->SetMargin(arg2);
52967 wxPyEndAllowThreads(__tstate);
52968 if (PyErr_Occurred()) SWIG_fail;
52969 }
52970 resultobj = SWIG_Py_Void();
52971 return resultobj;
52972 fail:
52973 return NULL;
52974 }
52975
52976
52977 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52978 PyObject *resultobj = 0;
52979 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52980 int result;
52981 void *argp1 = 0 ;
52982 int res1 = 0 ;
52983 PyObject *swig_obj[1] ;
52984
52985 if (!args) SWIG_fail;
52986 swig_obj[0] = args;
52987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52988 if (!SWIG_IsOK(res1)) {
52989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52990 }
52991 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52992 {
52993 PyThreadState* __tstate = wxPyBeginAllowThreads();
52994 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52995 wxPyEndAllowThreads(__tstate);
52996 if (PyErr_Occurred()) SWIG_fail;
52997 }
52998 resultobj = SWIG_From_int(static_cast< int >(result));
52999 return resultobj;
53000 fail:
53001 return NULL;
53002 }
53003
53004
53005 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53006 PyObject *resultobj = 0;
53007 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53008 int result;
53009 void *argp1 = 0 ;
53010 int res1 = 0 ;
53011 PyObject *swig_obj[1] ;
53012
53013 if (!args) SWIG_fail;
53014 swig_obj[0] = args;
53015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53016 if (!SWIG_IsOK(res1)) {
53017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53018 }
53019 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53020 {
53021 PyThreadState* __tstate = wxPyBeginAllowThreads();
53022 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53023 wxPyEndAllowThreads(__tstate);
53024 if (PyErr_Occurred()) SWIG_fail;
53025 }
53026 resultobj = SWIG_From_int(static_cast< int >(result));
53027 return resultobj;
53028 fail:
53029 return NULL;
53030 }
53031
53032
53033 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53034 PyObject *resultobj = 0;
53035 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53036 int result;
53037 void *argp1 = 0 ;
53038 int res1 = 0 ;
53039 PyObject *swig_obj[1] ;
53040
53041 if (!args) SWIG_fail;
53042 swig_obj[0] = args;
53043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53044 if (!SWIG_IsOK(res1)) {
53045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53046 }
53047 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53048 {
53049 PyThreadState* __tstate = wxPyBeginAllowThreads();
53050 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53051 wxPyEndAllowThreads(__tstate);
53052 if (PyErr_Occurred()) SWIG_fail;
53053 }
53054 resultobj = SWIG_From_int(static_cast< int >(result));
53055 return resultobj;
53056 fail:
53057 return NULL;
53058 }
53059
53060
53061 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53062 PyObject *resultobj = 0;
53063 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53064 bool result;
53065 void *argp1 = 0 ;
53066 int res1 = 0 ;
53067 PyObject *swig_obj[1] ;
53068
53069 if (!args) SWIG_fail;
53070 swig_obj[0] = args;
53071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53072 if (!SWIG_IsOK(res1)) {
53073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53074 }
53075 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53076 {
53077 PyThreadState* __tstate = wxPyBeginAllowThreads();
53078 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53079 wxPyEndAllowThreads(__tstate);
53080 if (PyErr_Occurred()) SWIG_fail;
53081 }
53082 {
53083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53084 }
53085 return resultobj;
53086 fail:
53087 return NULL;
53088 }
53089
53090
53091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53092 PyObject *resultobj = 0;
53093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53094 bool arg2 ;
53095 void *argp1 = 0 ;
53096 int res1 = 0 ;
53097 bool val2 ;
53098 int ecode2 = 0 ;
53099 PyObject * obj0 = 0 ;
53100 PyObject * obj1 = 0 ;
53101 char * kwnames[] = {
53102 (char *) "self",(char *) "d", NULL
53103 };
53104
53105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53107 if (!SWIG_IsOK(res1)) {
53108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53109 }
53110 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53111 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53112 if (!SWIG_IsOK(ecode2)) {
53113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53114 }
53115 arg2 = static_cast< bool >(val2);
53116 {
53117 PyThreadState* __tstate = wxPyBeginAllowThreads();
53118 (arg1)->SetDone(arg2);
53119 wxPyEndAllowThreads(__tstate);
53120 if (PyErr_Occurred()) SWIG_fail;
53121 }
53122 resultobj = SWIG_Py_Void();
53123 return resultobj;
53124 fail:
53125 return NULL;
53126 }
53127
53128
53129 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53130 PyObject *resultobj = 0;
53131 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53132 wxRelationship result;
53133 void *argp1 = 0 ;
53134 int res1 = 0 ;
53135 PyObject *swig_obj[1] ;
53136
53137 if (!args) SWIG_fail;
53138 swig_obj[0] = args;
53139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53140 if (!SWIG_IsOK(res1)) {
53141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53142 }
53143 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53144 {
53145 PyThreadState* __tstate = wxPyBeginAllowThreads();
53146 result = (wxRelationship)(arg1)->GetRelationship();
53147 wxPyEndAllowThreads(__tstate);
53148 if (PyErr_Occurred()) SWIG_fail;
53149 }
53150 resultobj = SWIG_From_int(static_cast< int >(result));
53151 return resultobj;
53152 fail:
53153 return NULL;
53154 }
53155
53156
53157 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53158 PyObject *resultobj = 0;
53159 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53160 wxRelationship arg2 ;
53161 void *argp1 = 0 ;
53162 int res1 = 0 ;
53163 int val2 ;
53164 int ecode2 = 0 ;
53165 PyObject * obj0 = 0 ;
53166 PyObject * obj1 = 0 ;
53167 char * kwnames[] = {
53168 (char *) "self",(char *) "r", NULL
53169 };
53170
53171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53173 if (!SWIG_IsOK(res1)) {
53174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53175 }
53176 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53177 ecode2 = SWIG_AsVal_int(obj1, &val2);
53178 if (!SWIG_IsOK(ecode2)) {
53179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53180 }
53181 arg2 = static_cast< wxRelationship >(val2);
53182 {
53183 PyThreadState* __tstate = wxPyBeginAllowThreads();
53184 (arg1)->SetRelationship(arg2);
53185 wxPyEndAllowThreads(__tstate);
53186 if (PyErr_Occurred()) SWIG_fail;
53187 }
53188 resultobj = SWIG_Py_Void();
53189 return resultobj;
53190 fail:
53191 return NULL;
53192 }
53193
53194
53195 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53196 PyObject *resultobj = 0;
53197 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53198 wxWindow *arg2 = (wxWindow *) 0 ;
53199 bool result;
53200 void *argp1 = 0 ;
53201 int res1 = 0 ;
53202 void *argp2 = 0 ;
53203 int res2 = 0 ;
53204 PyObject * obj0 = 0 ;
53205 PyObject * obj1 = 0 ;
53206 char * kwnames[] = {
53207 (char *) "self",(char *) "otherW", NULL
53208 };
53209
53210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53212 if (!SWIG_IsOK(res1)) {
53213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53214 }
53215 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53217 if (!SWIG_IsOK(res2)) {
53218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53219 }
53220 arg2 = reinterpret_cast< wxWindow * >(argp2);
53221 {
53222 PyThreadState* __tstate = wxPyBeginAllowThreads();
53223 result = (bool)(arg1)->ResetIfWin(arg2);
53224 wxPyEndAllowThreads(__tstate);
53225 if (PyErr_Occurred()) SWIG_fail;
53226 }
53227 {
53228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53229 }
53230 return resultobj;
53231 fail:
53232 return NULL;
53233 }
53234
53235
53236 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53237 PyObject *resultobj = 0;
53238 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53239 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53240 wxWindow *arg3 = (wxWindow *) 0 ;
53241 bool result;
53242 void *argp1 = 0 ;
53243 int res1 = 0 ;
53244 void *argp2 = 0 ;
53245 int res2 = 0 ;
53246 void *argp3 = 0 ;
53247 int res3 = 0 ;
53248 PyObject * obj0 = 0 ;
53249 PyObject * obj1 = 0 ;
53250 PyObject * obj2 = 0 ;
53251 char * kwnames[] = {
53252 (char *) "self",(char *) "constraints",(char *) "win", NULL
53253 };
53254
53255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53257 if (!SWIG_IsOK(res1)) {
53258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53259 }
53260 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53262 if (!SWIG_IsOK(res2)) {
53263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53264 }
53265 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53266 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53267 if (!SWIG_IsOK(res3)) {
53268 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53269 }
53270 arg3 = reinterpret_cast< wxWindow * >(argp3);
53271 {
53272 PyThreadState* __tstate = wxPyBeginAllowThreads();
53273 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53274 wxPyEndAllowThreads(__tstate);
53275 if (PyErr_Occurred()) SWIG_fail;
53276 }
53277 {
53278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53279 }
53280 return resultobj;
53281 fail:
53282 return NULL;
53283 }
53284
53285
53286 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53287 PyObject *resultobj = 0;
53288 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53289 wxEdge arg2 ;
53290 wxWindow *arg3 = (wxWindow *) 0 ;
53291 wxWindow *arg4 = (wxWindow *) 0 ;
53292 int result;
53293 void *argp1 = 0 ;
53294 int res1 = 0 ;
53295 int val2 ;
53296 int ecode2 = 0 ;
53297 void *argp3 = 0 ;
53298 int res3 = 0 ;
53299 void *argp4 = 0 ;
53300 int res4 = 0 ;
53301 PyObject * obj0 = 0 ;
53302 PyObject * obj1 = 0 ;
53303 PyObject * obj2 = 0 ;
53304 PyObject * obj3 = 0 ;
53305 char * kwnames[] = {
53306 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53307 };
53308
53309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53311 if (!SWIG_IsOK(res1)) {
53312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53313 }
53314 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53315 ecode2 = SWIG_AsVal_int(obj1, &val2);
53316 if (!SWIG_IsOK(ecode2)) {
53317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53318 }
53319 arg2 = static_cast< wxEdge >(val2);
53320 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53321 if (!SWIG_IsOK(res3)) {
53322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53323 }
53324 arg3 = reinterpret_cast< wxWindow * >(argp3);
53325 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53326 if (!SWIG_IsOK(res4)) {
53327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53328 }
53329 arg4 = reinterpret_cast< wxWindow * >(argp4);
53330 {
53331 PyThreadState* __tstate = wxPyBeginAllowThreads();
53332 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53333 wxPyEndAllowThreads(__tstate);
53334 if (PyErr_Occurred()) SWIG_fail;
53335 }
53336 resultobj = SWIG_From_int(static_cast< int >(result));
53337 return resultobj;
53338 fail:
53339 return NULL;
53340 }
53341
53342
53343 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53344 PyObject *obj;
53345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53346 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53347 return SWIG_Py_Void();
53348 }
53349
53350 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53351 PyObject *resultobj = 0;
53352 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53353 wxIndividualLayoutConstraint *result = 0 ;
53354 void *argp1 = 0 ;
53355 int res1 = 0 ;
53356 PyObject *swig_obj[1] ;
53357
53358 if (!args) SWIG_fail;
53359 swig_obj[0] = args;
53360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53361 if (!SWIG_IsOK(res1)) {
53362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53363 }
53364 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53365 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53367 return resultobj;
53368 fail:
53369 return NULL;
53370 }
53371
53372
53373 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53374 PyObject *resultobj = 0;
53375 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53376 wxIndividualLayoutConstraint *result = 0 ;
53377 void *argp1 = 0 ;
53378 int res1 = 0 ;
53379 PyObject *swig_obj[1] ;
53380
53381 if (!args) SWIG_fail;
53382 swig_obj[0] = args;
53383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53384 if (!SWIG_IsOK(res1)) {
53385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53386 }
53387 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53388 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53390 return resultobj;
53391 fail:
53392 return NULL;
53393 }
53394
53395
53396 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53397 PyObject *resultobj = 0;
53398 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53399 wxIndividualLayoutConstraint *result = 0 ;
53400 void *argp1 = 0 ;
53401 int res1 = 0 ;
53402 PyObject *swig_obj[1] ;
53403
53404 if (!args) SWIG_fail;
53405 swig_obj[0] = args;
53406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53407 if (!SWIG_IsOK(res1)) {
53408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53409 }
53410 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53411 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53413 return resultobj;
53414 fail:
53415 return NULL;
53416 }
53417
53418
53419 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53420 PyObject *resultobj = 0;
53421 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53422 wxIndividualLayoutConstraint *result = 0 ;
53423 void *argp1 = 0 ;
53424 int res1 = 0 ;
53425 PyObject *swig_obj[1] ;
53426
53427 if (!args) SWIG_fail;
53428 swig_obj[0] = args;
53429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53430 if (!SWIG_IsOK(res1)) {
53431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53432 }
53433 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53434 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53436 return resultobj;
53437 fail:
53438 return NULL;
53439 }
53440
53441
53442 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53443 PyObject *resultobj = 0;
53444 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53445 wxIndividualLayoutConstraint *result = 0 ;
53446 void *argp1 = 0 ;
53447 int res1 = 0 ;
53448 PyObject *swig_obj[1] ;
53449
53450 if (!args) SWIG_fail;
53451 swig_obj[0] = args;
53452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53453 if (!SWIG_IsOK(res1)) {
53454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53455 }
53456 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53457 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53459 return resultobj;
53460 fail:
53461 return NULL;
53462 }
53463
53464
53465 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53466 PyObject *resultobj = 0;
53467 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53468 wxIndividualLayoutConstraint *result = 0 ;
53469 void *argp1 = 0 ;
53470 int res1 = 0 ;
53471 PyObject *swig_obj[1] ;
53472
53473 if (!args) SWIG_fail;
53474 swig_obj[0] = args;
53475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53476 if (!SWIG_IsOK(res1)) {
53477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53478 }
53479 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53480 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53482 return resultobj;
53483 fail:
53484 return NULL;
53485 }
53486
53487
53488 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53489 PyObject *resultobj = 0;
53490 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53491 wxIndividualLayoutConstraint *result = 0 ;
53492 void *argp1 = 0 ;
53493 int res1 = 0 ;
53494 PyObject *swig_obj[1] ;
53495
53496 if (!args) SWIG_fail;
53497 swig_obj[0] = args;
53498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53499 if (!SWIG_IsOK(res1)) {
53500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53501 }
53502 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53503 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53505 return resultobj;
53506 fail:
53507 return NULL;
53508 }
53509
53510
53511 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53512 PyObject *resultobj = 0;
53513 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53514 wxIndividualLayoutConstraint *result = 0 ;
53515 void *argp1 = 0 ;
53516 int res1 = 0 ;
53517 PyObject *swig_obj[1] ;
53518
53519 if (!args) SWIG_fail;
53520 swig_obj[0] = args;
53521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53522 if (!SWIG_IsOK(res1)) {
53523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53524 }
53525 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53526 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53528 return resultobj;
53529 fail:
53530 return NULL;
53531 }
53532
53533
53534 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53535 PyObject *resultobj = 0;
53536 wxLayoutConstraints *result = 0 ;
53537
53538 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53539 {
53540 PyThreadState* __tstate = wxPyBeginAllowThreads();
53541 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53542 wxPyEndAllowThreads(__tstate);
53543 if (PyErr_Occurred()) SWIG_fail;
53544 }
53545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53546 return resultobj;
53547 fail:
53548 return NULL;
53549 }
53550
53551
53552 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53553 PyObject *resultobj = 0;
53554 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53555 void *argp1 = 0 ;
53556 int res1 = 0 ;
53557 PyObject *swig_obj[1] ;
53558
53559 if (!args) SWIG_fail;
53560 swig_obj[0] = args;
53561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53562 if (!SWIG_IsOK(res1)) {
53563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53564 }
53565 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53566 {
53567 PyThreadState* __tstate = wxPyBeginAllowThreads();
53568 delete arg1;
53569
53570 wxPyEndAllowThreads(__tstate);
53571 if (PyErr_Occurred()) SWIG_fail;
53572 }
53573 resultobj = SWIG_Py_Void();
53574 return resultobj;
53575 fail:
53576 return NULL;
53577 }
53578
53579
53580 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53581 PyObject *resultobj = 0;
53582 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53583 wxWindow *arg2 = (wxWindow *) 0 ;
53584 int *arg3 = (int *) 0 ;
53585 bool result;
53586 void *argp1 = 0 ;
53587 int res1 = 0 ;
53588 void *argp2 = 0 ;
53589 int res2 = 0 ;
53590 int temp3 ;
53591 int res3 = SWIG_TMPOBJ ;
53592 PyObject * obj0 = 0 ;
53593 PyObject * obj1 = 0 ;
53594 char * kwnames[] = {
53595 (char *) "self",(char *) "win", NULL
53596 };
53597
53598 arg3 = &temp3;
53599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53601 if (!SWIG_IsOK(res1)) {
53602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53603 }
53604 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53606 if (!SWIG_IsOK(res2)) {
53607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53608 }
53609 arg2 = reinterpret_cast< wxWindow * >(argp2);
53610 {
53611 PyThreadState* __tstate = wxPyBeginAllowThreads();
53612 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53613 wxPyEndAllowThreads(__tstate);
53614 if (PyErr_Occurred()) SWIG_fail;
53615 }
53616 {
53617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53618 }
53619 if (SWIG_IsTmpObj(res3)) {
53620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53621 } else {
53622 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53624 }
53625 return resultobj;
53626 fail:
53627 return NULL;
53628 }
53629
53630
53631 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53632 PyObject *resultobj = 0;
53633 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53634 bool result;
53635 void *argp1 = 0 ;
53636 int res1 = 0 ;
53637 PyObject *swig_obj[1] ;
53638
53639 if (!args) SWIG_fail;
53640 swig_obj[0] = args;
53641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53642 if (!SWIG_IsOK(res1)) {
53643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53644 }
53645 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53646 {
53647 PyThreadState* __tstate = wxPyBeginAllowThreads();
53648 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53649 wxPyEndAllowThreads(__tstate);
53650 if (PyErr_Occurred()) SWIG_fail;
53651 }
53652 {
53653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53654 }
53655 return resultobj;
53656 fail:
53657 return NULL;
53658 }
53659
53660
53661 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53662 PyObject *obj;
53663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53664 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53665 return SWIG_Py_Void();
53666 }
53667
53668 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53669 return SWIG_Python_InitShadowInstance(args);
53670 }
53671
53672 static PyMethodDef SwigMethods[] = {
53673 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53674 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53675 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53676 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53677 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53678 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53679 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53680 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53681 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53683 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53694 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53695 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53696 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53698 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53699 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53700 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53701 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53702 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53703 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53704 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53706 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53712 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53713 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53714 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53715 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53716 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53717 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53718 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53720 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53728 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53729 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53730 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53735 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53736 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53738 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53740 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53742 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53744 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53746 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53748 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53749 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53751 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53753 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53754 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53755 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53756 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53776 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53777 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53778 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53779 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53780 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53781 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53782 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53783 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53785 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53786 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53787 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53792 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53793 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53794 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53795 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53802 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53809 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53810 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53811 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53812 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53814 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53815 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53816 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53818 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53819 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53820 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53821 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53826 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53827 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53828 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53829 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53830 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53831 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53834 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53835 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53836 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53838 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53839 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53841 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53842 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53843 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53844 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53845 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53846 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53847 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53848 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53849 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53850 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53851 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53852 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53857 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53863 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53864 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53865 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53866 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53868 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53871 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53874 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53877 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53879 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53882 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53883 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53884 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53888 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53889 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53890 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53894 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53899 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53900 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53901 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53902 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53903 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53904 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53905 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53912 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53913 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53915 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53916 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53917 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53923 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53924 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53926 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53927 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53928 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53929 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53930 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53931 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53932 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53933 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53935 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53936 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53937 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53938 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53939 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53940 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53941 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53942 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53944 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53953 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53965 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53966 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53981 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53982 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53983 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53984 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53987 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53989 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53991 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53993 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53995 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53998 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53999 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54000 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54001 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54003 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54020 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54021 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54027 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54028 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54030 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54031 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54032 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54033 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54034 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54035 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54036 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54037 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54038 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54039 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54040 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54041 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54042 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54043 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54044 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54045 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54046 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54047 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54048 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54049 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54050 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54051 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54052 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54053 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54054 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54055 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54056 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54057 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54058 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54059 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54060 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54061 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54062 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54064 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54065 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54066 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54067 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54070 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54074 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54078 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54079 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54080 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54081 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54083 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54084 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54086 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54088 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54090 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54092 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54093 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54094 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54096 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54097 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54099 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54100 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54101 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54103 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54104 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54105 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54107 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54109 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54110 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54111 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54113 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54115 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54116 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54118 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54119 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54120 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54122 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54123 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54124 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54125 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54126 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54128 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54129 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54132 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54133 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54135 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54136 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54139 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54140 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54142 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54148 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54149 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54150 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54151 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54152 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54153 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54154 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54155 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54156 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54157 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54158 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54159 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54160 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54161 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54162 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54163 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54164 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54165 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54166 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54167 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54168 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54169 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54170 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54171 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54173 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54174 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54175 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54176 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54177 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54178 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54179 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54180 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54181 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54182 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54183 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54184 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54185 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54186 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54187 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54188 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54189 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54190 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54191 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54192 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54193 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54194 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54195 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54196 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54197 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54198 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54199 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54200 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54201 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54202 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54203 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54204 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54206 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54207 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54209 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54210 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54211 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54212 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54214 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54215 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54216 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54217 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54218 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54219 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54220 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54221 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54222 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54224 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54225 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54226 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54227 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54228 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54229 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54230 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54231 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54232 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54233 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54234 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54235 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54236 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54237 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54238 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54239 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54240 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54241 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54242 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54243 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54244 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54245 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54246 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54247 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54248 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54249 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54250 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54251 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54253 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54254 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54257 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54258 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54259 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54260 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54261 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54262 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54264 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54265 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54268 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54269 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54271 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54272 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54274 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54275 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54277 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54278 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54279 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54281 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54283 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54284 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54286 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54287 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54288 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54290 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54291 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54292 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54294 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54295 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54297 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54298 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54299 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54300 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54301 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54304 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54306 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54308 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54309 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54310 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54313 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54314 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54315 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54317 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54318 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54319 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54321 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54322 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54323 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54324 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54325 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54326 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54328 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54329 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54330 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54331 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54332 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54333 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54334 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54335 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54341 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54343 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54345 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54346 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54347 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54348 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54349 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54350 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54352 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54353 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54354 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54356 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54357 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54358 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54359 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54360 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54363 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54364 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54365 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54368 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54369 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54371 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54372 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54374 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54376 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54379 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54381 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54382 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54384 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54385 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54386 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54388 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54389 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54390 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54392 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54394 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54395 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54396 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54398 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54400 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54402 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54403 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54405 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54406 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54408 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54410 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54411 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54412 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54414 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54416 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54417 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54418 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54420 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54422 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54423 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54424 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54425 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54427 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54429 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54431 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54433 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54434 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54436 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54437 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54438 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54439 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54440 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54441 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54442 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54443 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54444 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54446 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54448 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54450 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54452 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54454 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54456 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54457 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54458 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54459 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54460 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54461 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54467 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54468 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
54469 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54470 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54471 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54472 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54473 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54474 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54476 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54478 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54479 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54481 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54482 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54483 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54484 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54486 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54487 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54488 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54489 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54491 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54492 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54494 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54495 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54496 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54498 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54501 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54502 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54503 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54504 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54505 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54507 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54508 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54510 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54511 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54512 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54513 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54515 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54516 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54517 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54518 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54519 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54520 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54521 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54522 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54523 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54524 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54526 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54529 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54530 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54531 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54533 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54535 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54537 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54539 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54540 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54543 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54553 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54554 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54555 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54556 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54558 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54559 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54560 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54561 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54562 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54563 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54564 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54565 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54566 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54567 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54568 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54569 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54570 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54571 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54572 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54574 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54575 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54578 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54579 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54584 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54585 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54588 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54589 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54590 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54591 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54594 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54595 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54596 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54598 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54600 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54601 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54602 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54604 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54606 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54608 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54611 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54612 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54613 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54614 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54615 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54616 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54620 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54621 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54622 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54623 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54630 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54636 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54637 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54638 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54639 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54640 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54642 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54652 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54653 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54654 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54655 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54658 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54659 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54660 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54661 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54663 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54664 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54665 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54668 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54674 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54675 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54676 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54677 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54679 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54680 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54682 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54685 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54687 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54688 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54689 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54691 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54698 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54702 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54703 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54705 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54715 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54716 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54717 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54718 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54722 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54725 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54727 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54730 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54732 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54733 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54736 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54738 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54739 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54740 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54741 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54742 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54743 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54744 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54749 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54750 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54751 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54753 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54754 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54755 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54757 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54759 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54760 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54761 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54763 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54764 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54767 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54775 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54782 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54790 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54793 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54794 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54807 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54809 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54811 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54812 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54814 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54816 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54817 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54819 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54820 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54821 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54825 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54844 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54845 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54847 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54848 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54850 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54851 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54852 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54854 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54855 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54858 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54859 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54861 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54862 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54864 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54867 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54868 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54870 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54872 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54874 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54875 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54877 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54878 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54881 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54883 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54885 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54887 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54890 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54892 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54893 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54894 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54896 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54897 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54898 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54900 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54902 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54903 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54905 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54907 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54908 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54912 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54916 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54917 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54919 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54923 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54925 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54927 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54928 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54929 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54930 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54934 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54935 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54936 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54937 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54939 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54940 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54945 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54946 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54947 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54948 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54949 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54951 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54953 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54955 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54956 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54958 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54960 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54963 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54964 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54965 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54967 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54968 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54969 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
54982 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54988 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54989 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54990 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54991 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54992 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54993 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54999 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55000 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55004 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55005 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55007 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55008 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55010 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55012 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55013 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55015 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55016 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55017 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55023 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55024 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55025 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55026 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55027 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55028 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55035 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55037 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55038 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55039 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55040 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55041 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55042 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55044 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55048 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55049 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55050 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55051 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55052 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55053 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55054 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55056 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55057 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55058 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55064 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55065 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55066 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55068 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55069 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55070 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55071 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55076 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55077 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55078 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55079 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55080 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55084 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55085 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55090 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55091 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55093 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55094 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55099 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55101 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55102 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55103 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55104 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55105 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55110 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55111 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55120 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55121 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55122 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55123 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55126 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55128 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55129 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55130 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55131 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55133 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55138 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55139 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55140 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55141 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55142 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55143 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55144 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55145 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55146 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55147 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55148 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55150 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55151 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55152 { NULL, NULL, 0, NULL }
55153 };
55154
55155
55156 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55157
55158 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55159 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55160 }
55161 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55162 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55163 }
55164 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55165 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55166 }
55167 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55168 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55169 }
55170 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55171 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55172 }
55173 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55174 return (void *)((wxSizer *) ((wxGridSizer *) x));
55175 }
55176 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55177 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55178 }
55179 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55180 return (void *)((wxSizer *) ((wxPySizer *) x));
55181 }
55182 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55183 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55184 }
55185 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55186 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55187 }
55188 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55189 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55190 }
55191 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55192 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55193 }
55194 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55195 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55196 }
55197 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55198 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55199 }
55200 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55201 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55202 }
55203 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55204 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55205 }
55206 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55207 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55208 }
55209 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55210 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55211 }
55212 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55213 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55214 }
55215 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55216 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55217 }
55218 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55219 return (void *)((wxEvent *) ((wxPyEvent *) x));
55220 }
55221 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55222 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55223 }
55224 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55226 }
55227 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55228 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55229 }
55230 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55231 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55232 }
55233 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55234 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55235 }
55236 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55237 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55238 }
55239 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55240 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55241 }
55242 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55243 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55244 }
55245 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55247 }
55248 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55249 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55250 }
55251 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55252 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55253 }
55254 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55255 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55256 }
55257 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55258 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55259 }
55260 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55261 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55262 }
55263 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55264 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55265 }
55266 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55267 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55268 }
55269 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55270 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55271 }
55272 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55273 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55274 }
55275 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55276 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55277 }
55278 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55280 }
55281 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55282 return (void *)((wxEvent *) ((wxShowEvent *) x));
55283 }
55284 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55285 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55286 }
55287 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55289 }
55290 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55291 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55292 }
55293 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55294 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55295 }
55296 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55297 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55298 }
55299 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55300 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55301 }
55302 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55303 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55304 }
55305 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55306 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55307 }
55308 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55309 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55310 }
55311 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55312 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55313 }
55314 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55315 return (void *)((wxControl *) ((wxControlWithItems *) x));
55316 }
55317 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55318 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55319 }
55320 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55321 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55322 }
55323 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55324 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55325 }
55326 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55327 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55328 }
55329 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55330 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55331 }
55332 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55333 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55334 }
55335 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55336 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55337 }
55338 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55339 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55340 }
55341 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55342 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55343 }
55344 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55345 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55346 }
55347 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55348 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55349 }
55350 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55351 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55352 }
55353 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55354 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55355 }
55356 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55357 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55358 }
55359 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55360 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55361 }
55362 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55363 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55364 }
55365 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55366 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55367 }
55368 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55369 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55370 }
55371 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55372 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55373 }
55374 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55375 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55376 }
55377 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55378 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55379 }
55380 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55381 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55382 }
55383 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55384 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55385 }
55386 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55387 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55388 }
55389 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55390 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55391 }
55392 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55393 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55394 }
55395 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55396 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55397 }
55398 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55399 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55400 }
55401 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55402 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55403 }
55404 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55405 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55406 }
55407 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55408 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55409 }
55410 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55411 return (void *)((wxObject *) ((wxSizerItem *) x));
55412 }
55413 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55414 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55415 }
55416 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55417 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55418 }
55419 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55420 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55421 }
55422 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55423 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55424 }
55425 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55426 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55427 }
55428 static void *_p_wxSizerTo_p_wxObject(void *x) {
55429 return (void *)((wxObject *) ((wxSizer *) x));
55430 }
55431 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55432 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55433 }
55434 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55436 }
55437 static void *_p_wxEventTo_p_wxObject(void *x) {
55438 return (void *)((wxObject *) ((wxEvent *) x));
55439 }
55440 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55441 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55442 }
55443 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55444 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55445 }
55446 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55447 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55448 }
55449 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55450 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55451 }
55452 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55453 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55454 }
55455 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55456 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55457 }
55458 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55459 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55460 }
55461 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55462 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55463 }
55464 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55465 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55466 }
55467 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55468 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55469 }
55470 static void *_p_wxControlTo_p_wxObject(void *x) {
55471 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55472 }
55473 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55474 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55475 }
55476 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55477 return (void *)((wxObject *) ((wxFSFile *) x));
55478 }
55479 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55480 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55481 }
55482 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55483 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55484 }
55485 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55487 }
55488 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55489 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55490 }
55491 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55492 return (void *)((wxObject *) ((wxMenuItem *) x));
55493 }
55494 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55496 }
55497 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55498 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55499 }
55500 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55501 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55502 }
55503 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55504 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55505 }
55506 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55507 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55508 }
55509 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55510 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55511 }
55512 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55513 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55514 }
55515 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55516 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55517 }
55518 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55519 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55520 }
55521 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55522 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55523 }
55524 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55525 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55526 }
55527 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55528 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55529 }
55530 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55531 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55532 }
55533 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55534 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55535 }
55536 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55537 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55538 }
55539 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55540 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55541 }
55542 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55543 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55544 }
55545 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55546 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55547 }
55548 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55549 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55550 }
55551 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55552 return (void *)((wxObject *) ((wxImageHandler *) x));
55553 }
55554 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55555 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55556 }
55557 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55558 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55559 }
55560 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55561 return (void *)((wxObject *) ((wxEvtHandler *) x));
55562 }
55563 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55564 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55565 }
55566 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55567 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55568 }
55569 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55570 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55571 }
55572 static void *_p_wxImageTo_p_wxObject(void *x) {
55573 return (void *)((wxObject *) ((wxImage *) x));
55574 }
55575 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55576 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55577 }
55578 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55579 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55580 }
55581 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55582 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55583 }
55584 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55585 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55586 }
55587 static void *_p_wxWindowTo_p_wxObject(void *x) {
55588 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55589 }
55590 static void *_p_wxMenuTo_p_wxObject(void *x) {
55591 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55592 }
55593 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55594 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55595 }
55596 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55597 return (void *)((wxObject *) ((wxFileSystem *) x));
55598 }
55599 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55601 }
55602 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55603 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55604 }
55605 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55606 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55607 }
55608 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55609 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55610 }
55611 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55612 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55613 }
55614 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55615 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55616 }
55617 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55619 }
55620 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55621 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55622 }
55623 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55624 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55625 }
55626 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55627 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55628 }
55629 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55631 }
55632 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55634 }
55635 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55636 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55637 }
55638 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55639 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55640 }
55641 static void *_p_wxControlTo_p_wxWindow(void *x) {
55642 return (void *)((wxWindow *) ((wxControl *) x));
55643 }
55644 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55645 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55646 }
55647 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55648 return (void *)((wxWindow *) ((wxMenuBar *) x));
55649 }
55650 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55651 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55652 }
55653 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55654 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55655 }
55656 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55657 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55658 }
55659 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55660 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55661 }
55662 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55663 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55664 }
55665 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55666 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55667 }
55668 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55669 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55670 }
55671 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55672 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55673 }
55674 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55675 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55676 }
55677 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55678 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55679 }
55680 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55681 return (void *)((wxValidator *) ((wxPyValidator *) x));
55682 }
55683 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55684 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55685 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};
55686 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55687 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55688 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55689 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55690 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55691 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55692 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55693 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55694 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55695 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55696 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55697 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55698 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55699 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55700 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55701 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55702 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55703 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55704 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55705 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55706 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55707 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55708 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55709 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55710 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55711 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55712 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55713 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55714 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55715 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55716 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55717 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55718 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55719 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55720 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55721 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55722 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55723 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55724 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55725 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55726 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55727 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55728 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55729 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55730 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55731 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55732 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55733 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55734 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55735 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55736 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55737 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55738 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55739 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55740 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55741 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55742 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55743 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55744 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55745 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55748 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55816
55817 static swig_type_info *swig_type_initial[] = {
55818 &_swigt__p_buffer,
55819 &_swigt__p_char,
55820 &_swigt__p_form_ops_t,
55821 &_swigt__p_int,
55822 &_swigt__p_long,
55823 &_swigt__p_unsigned_char,
55824 &_swigt__p_unsigned_int,
55825 &_swigt__p_unsigned_long,
55826 &_swigt__p_wxANIHandler,
55827 &_swigt__p_wxAcceleratorEntry,
55828 &_swigt__p_wxAcceleratorTable,
55829 &_swigt__p_wxActivateEvent,
55830 &_swigt__p_wxAppTraits,
55831 &_swigt__p_wxArrayString,
55832 &_swigt__p_wxBMPHandler,
55833 &_swigt__p_wxBitmap,
55834 &_swigt__p_wxBoxSizer,
55835 &_swigt__p_wxButton,
55836 &_swigt__p_wxCURHandler,
55837 &_swigt__p_wxCaret,
55838 &_swigt__p_wxChildFocusEvent,
55839 &_swigt__p_wxClipboardTextEvent,
55840 &_swigt__p_wxCloseEvent,
55841 &_swigt__p_wxColour,
55842 &_swigt__p_wxCommandEvent,
55843 &_swigt__p_wxContextMenuEvent,
55844 &_swigt__p_wxControl,
55845 &_swigt__p_wxControlWithItems,
55846 &_swigt__p_wxCursor,
55847 &_swigt__p_wxDC,
55848 &_swigt__p_wxDateEvent,
55849 &_swigt__p_wxDateTime,
55850 &_swigt__p_wxDisplayChangedEvent,
55851 &_swigt__p_wxDropFilesEvent,
55852 &_swigt__p_wxDuplexMode,
55853 &_swigt__p_wxEraseEvent,
55854 &_swigt__p_wxEvent,
55855 &_swigt__p_wxEventLoop,
55856 &_swigt__p_wxEventLoopActivator,
55857 &_swigt__p_wxEvtHandler,
55858 &_swigt__p_wxFSFile,
55859 &_swigt__p_wxFileSystem,
55860 &_swigt__p_wxFileSystemHandler,
55861 &_swigt__p_wxFlexGridSizer,
55862 &_swigt__p_wxFocusEvent,
55863 &_swigt__p_wxFont,
55864 &_swigt__p_wxFrame,
55865 &_swigt__p_wxGBPosition,
55866 &_swigt__p_wxGBSizerItem,
55867 &_swigt__p_wxGBSpan,
55868 &_swigt__p_wxGIFHandler,
55869 &_swigt__p_wxGridBagSizer,
55870 &_swigt__p_wxGridSizer,
55871 &_swigt__p_wxHelpEvent__Origin,
55872 &_swigt__p_wxICOHandler,
55873 &_swigt__p_wxIconizeEvent,
55874 &_swigt__p_wxIdleEvent,
55875 &_swigt__p_wxImage,
55876 &_swigt__p_wxImageHandler,
55877 &_swigt__p_wxImageHistogram,
55878 &_swigt__p_wxImage_HSVValue,
55879 &_swigt__p_wxImage_RGBValue,
55880 &_swigt__p_wxIndividualLayoutConstraint,
55881 &_swigt__p_wxInitDialogEvent,
55882 &_swigt__p_wxInputStream,
55883 &_swigt__p_wxInternetFSHandler,
55884 &_swigt__p_wxItemContainer,
55885 &_swigt__p_wxJPEGHandler,
55886 &_swigt__p_wxKeyEvent,
55887 &_swigt__p_wxLayoutConstraints,
55888 &_swigt__p_wxLayoutDirection,
55889 &_swigt__p_wxMaximizeEvent,
55890 &_swigt__p_wxMemoryFSHandler,
55891 &_swigt__p_wxMenu,
55892 &_swigt__p_wxMenuBar,
55893 &_swigt__p_wxMenuBarBase,
55894 &_swigt__p_wxMenuEvent,
55895 &_swigt__p_wxMenuItem,
55896 &_swigt__p_wxMouseCaptureChangedEvent,
55897 &_swigt__p_wxMouseCaptureLostEvent,
55898 &_swigt__p_wxMouseEvent,
55899 &_swigt__p_wxMoveEvent,
55900 &_swigt__p_wxNavigationKeyEvent,
55901 &_swigt__p_wxNcPaintEvent,
55902 &_swigt__p_wxNotifyEvent,
55903 &_swigt__p_wxObject,
55904 &_swigt__p_wxOutputStream,
55905 &_swigt__p_wxPCXHandler,
55906 &_swigt__p_wxPNGHandler,
55907 &_swigt__p_wxPNMHandler,
55908 &_swigt__p_wxPaintEvent,
55909 &_swigt__p_wxPaletteChangedEvent,
55910 &_swigt__p_wxPaperSize,
55911 &_swigt__p_wxPoint,
55912 &_swigt__p_wxPoint2D,
55913 &_swigt__p_wxPropagateOnce,
55914 &_swigt__p_wxPropagationDisabler,
55915 &_swigt__p_wxPyApp,
55916 &_swigt__p_wxPyCommandEvent,
55917 &_swigt__p_wxPyDropTarget,
55918 &_swigt__p_wxPyEvent,
55919 &_swigt__p_wxPyFileSystemHandler,
55920 &_swigt__p_wxPyImageHandler,
55921 &_swigt__p_wxPyInputStream,
55922 &_swigt__p_wxPySizer,
55923 &_swigt__p_wxPyValidator,
55924 &_swigt__p_wxQuantize,
55925 &_swigt__p_wxQueryNewPaletteEvent,
55926 &_swigt__p_wxRealPoint,
55927 &_swigt__p_wxRect,
55928 &_swigt__p_wxRegion,
55929 &_swigt__p_wxScrollEvent,
55930 &_swigt__p_wxScrollWinEvent,
55931 &_swigt__p_wxSetCursorEvent,
55932 &_swigt__p_wxShowEvent,
55933 &_swigt__p_wxSize,
55934 &_swigt__p_wxSizeEvent,
55935 &_swigt__p_wxSizer,
55936 &_swigt__p_wxSizerItem,
55937 &_swigt__p_wxStaticBox,
55938 &_swigt__p_wxStaticBoxSizer,
55939 &_swigt__p_wxStdDialogButtonSizer,
55940 &_swigt__p_wxSysColourChangedEvent,
55941 &_swigt__p_wxTIFFHandler,
55942 &_swigt__p_wxToolTip,
55943 &_swigt__p_wxUpdateUIEvent,
55944 &_swigt__p_wxValidator,
55945 &_swigt__p_wxVisualAttributes,
55946 &_swigt__p_wxWindow,
55947 &_swigt__p_wxWindowCreateEvent,
55948 &_swigt__p_wxWindowDestroyEvent,
55949 &_swigt__p_wxXPMHandler,
55950 &_swigt__p_wxZipFSHandler,
55951 };
55952
55953 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55954 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55955 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55956 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55957 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55958 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55959 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55960 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55961 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55962 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55963 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55964 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55965 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55966 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55967 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}};
55968 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55969 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}};
55970 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55971 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}};
55972 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55973 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55974 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55975 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55976 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55977 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}};
55978 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55979 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}};
55980 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55981 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55982 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55983 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55984 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55985 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55986 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55987 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55988 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55989 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}};
55990 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55991 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55992 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}};
55993 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55994 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55995 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}};
55996 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}};
55997 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55998 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55999 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56000 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56001 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56002 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56003 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56004 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56005 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}};
56006 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56007 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}};
56008 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56009 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56010 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56011 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}};
56012 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56013 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56014 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56015 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56019 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}};
56020 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56021 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56022 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56023 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56029 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56030 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56031 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56032 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 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}};
56039 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56040 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56041 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56042 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56057 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56058 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56059 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56070 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}};
56071 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}};
56072 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56079 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}};
56080 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56081 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}};
56082 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56086
56087 static swig_cast_info *swig_cast_initial[] = {
56088 _swigc__p_buffer,
56089 _swigc__p_char,
56090 _swigc__p_form_ops_t,
56091 _swigc__p_int,
56092 _swigc__p_long,
56093 _swigc__p_unsigned_char,
56094 _swigc__p_unsigned_int,
56095 _swigc__p_unsigned_long,
56096 _swigc__p_wxANIHandler,
56097 _swigc__p_wxAcceleratorEntry,
56098 _swigc__p_wxAcceleratorTable,
56099 _swigc__p_wxActivateEvent,
56100 _swigc__p_wxAppTraits,
56101 _swigc__p_wxArrayString,
56102 _swigc__p_wxBMPHandler,
56103 _swigc__p_wxBitmap,
56104 _swigc__p_wxBoxSizer,
56105 _swigc__p_wxButton,
56106 _swigc__p_wxCURHandler,
56107 _swigc__p_wxCaret,
56108 _swigc__p_wxChildFocusEvent,
56109 _swigc__p_wxClipboardTextEvent,
56110 _swigc__p_wxCloseEvent,
56111 _swigc__p_wxColour,
56112 _swigc__p_wxCommandEvent,
56113 _swigc__p_wxContextMenuEvent,
56114 _swigc__p_wxControl,
56115 _swigc__p_wxControlWithItems,
56116 _swigc__p_wxCursor,
56117 _swigc__p_wxDC,
56118 _swigc__p_wxDateEvent,
56119 _swigc__p_wxDateTime,
56120 _swigc__p_wxDisplayChangedEvent,
56121 _swigc__p_wxDropFilesEvent,
56122 _swigc__p_wxDuplexMode,
56123 _swigc__p_wxEraseEvent,
56124 _swigc__p_wxEvent,
56125 _swigc__p_wxEventLoop,
56126 _swigc__p_wxEventLoopActivator,
56127 _swigc__p_wxEvtHandler,
56128 _swigc__p_wxFSFile,
56129 _swigc__p_wxFileSystem,
56130 _swigc__p_wxFileSystemHandler,
56131 _swigc__p_wxFlexGridSizer,
56132 _swigc__p_wxFocusEvent,
56133 _swigc__p_wxFont,
56134 _swigc__p_wxFrame,
56135 _swigc__p_wxGBPosition,
56136 _swigc__p_wxGBSizerItem,
56137 _swigc__p_wxGBSpan,
56138 _swigc__p_wxGIFHandler,
56139 _swigc__p_wxGridBagSizer,
56140 _swigc__p_wxGridSizer,
56141 _swigc__p_wxHelpEvent__Origin,
56142 _swigc__p_wxICOHandler,
56143 _swigc__p_wxIconizeEvent,
56144 _swigc__p_wxIdleEvent,
56145 _swigc__p_wxImage,
56146 _swigc__p_wxImageHandler,
56147 _swigc__p_wxImageHistogram,
56148 _swigc__p_wxImage_HSVValue,
56149 _swigc__p_wxImage_RGBValue,
56150 _swigc__p_wxIndividualLayoutConstraint,
56151 _swigc__p_wxInitDialogEvent,
56152 _swigc__p_wxInputStream,
56153 _swigc__p_wxInternetFSHandler,
56154 _swigc__p_wxItemContainer,
56155 _swigc__p_wxJPEGHandler,
56156 _swigc__p_wxKeyEvent,
56157 _swigc__p_wxLayoutConstraints,
56158 _swigc__p_wxLayoutDirection,
56159 _swigc__p_wxMaximizeEvent,
56160 _swigc__p_wxMemoryFSHandler,
56161 _swigc__p_wxMenu,
56162 _swigc__p_wxMenuBar,
56163 _swigc__p_wxMenuBarBase,
56164 _swigc__p_wxMenuEvent,
56165 _swigc__p_wxMenuItem,
56166 _swigc__p_wxMouseCaptureChangedEvent,
56167 _swigc__p_wxMouseCaptureLostEvent,
56168 _swigc__p_wxMouseEvent,
56169 _swigc__p_wxMoveEvent,
56170 _swigc__p_wxNavigationKeyEvent,
56171 _swigc__p_wxNcPaintEvent,
56172 _swigc__p_wxNotifyEvent,
56173 _swigc__p_wxObject,
56174 _swigc__p_wxOutputStream,
56175 _swigc__p_wxPCXHandler,
56176 _swigc__p_wxPNGHandler,
56177 _swigc__p_wxPNMHandler,
56178 _swigc__p_wxPaintEvent,
56179 _swigc__p_wxPaletteChangedEvent,
56180 _swigc__p_wxPaperSize,
56181 _swigc__p_wxPoint,
56182 _swigc__p_wxPoint2D,
56183 _swigc__p_wxPropagateOnce,
56184 _swigc__p_wxPropagationDisabler,
56185 _swigc__p_wxPyApp,
56186 _swigc__p_wxPyCommandEvent,
56187 _swigc__p_wxPyDropTarget,
56188 _swigc__p_wxPyEvent,
56189 _swigc__p_wxPyFileSystemHandler,
56190 _swigc__p_wxPyImageHandler,
56191 _swigc__p_wxPyInputStream,
56192 _swigc__p_wxPySizer,
56193 _swigc__p_wxPyValidator,
56194 _swigc__p_wxQuantize,
56195 _swigc__p_wxQueryNewPaletteEvent,
56196 _swigc__p_wxRealPoint,
56197 _swigc__p_wxRect,
56198 _swigc__p_wxRegion,
56199 _swigc__p_wxScrollEvent,
56200 _swigc__p_wxScrollWinEvent,
56201 _swigc__p_wxSetCursorEvent,
56202 _swigc__p_wxShowEvent,
56203 _swigc__p_wxSize,
56204 _swigc__p_wxSizeEvent,
56205 _swigc__p_wxSizer,
56206 _swigc__p_wxSizerItem,
56207 _swigc__p_wxStaticBox,
56208 _swigc__p_wxStaticBoxSizer,
56209 _swigc__p_wxStdDialogButtonSizer,
56210 _swigc__p_wxSysColourChangedEvent,
56211 _swigc__p_wxTIFFHandler,
56212 _swigc__p_wxToolTip,
56213 _swigc__p_wxUpdateUIEvent,
56214 _swigc__p_wxValidator,
56215 _swigc__p_wxVisualAttributes,
56216 _swigc__p_wxWindow,
56217 _swigc__p_wxWindowCreateEvent,
56218 _swigc__p_wxWindowDestroyEvent,
56219 _swigc__p_wxXPMHandler,
56220 _swigc__p_wxZipFSHandler,
56221 };
56222
56223
56224 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56225
56226 static swig_const_info swig_const_table[] = {
56227 {0, 0, 0, 0.0, 0, 0}};
56228
56229 #ifdef __cplusplus
56230 }
56231 #endif
56232 /* -----------------------------------------------------------------------------
56233 * Type initialization:
56234 * This problem is tough by the requirement that no dynamic
56235 * memory is used. Also, since swig_type_info structures store pointers to
56236 * swig_cast_info structures and swig_cast_info structures store pointers back
56237 * to swig_type_info structures, we need some lookup code at initialization.
56238 * The idea is that swig generates all the structures that are needed.
56239 * The runtime then collects these partially filled structures.
56240 * The SWIG_InitializeModule function takes these initial arrays out of
56241 * swig_module, and does all the lookup, filling in the swig_module.types
56242 * array with the correct data and linking the correct swig_cast_info
56243 * structures together.
56244 *
56245 * The generated swig_type_info structures are assigned staticly to an initial
56246 * array. We just loop though that array, and handle each type individually.
56247 * First we lookup if this type has been already loaded, and if so, use the
56248 * loaded structure instead of the generated one. Then we have to fill in the
56249 * cast linked list. The cast data is initially stored in something like a
56250 * two-dimensional array. Each row corresponds to a type (there are the same
56251 * number of rows as there are in the swig_type_initial array). Each entry in
56252 * a column is one of the swig_cast_info structures for that type.
56253 * The cast_initial array is actually an array of arrays, because each row has
56254 * a variable number of columns. So to actually build the cast linked list,
56255 * we find the array of casts associated with the type, and loop through it
56256 * adding the casts to the list. The one last trick we need to do is making
56257 * sure the type pointer in the swig_cast_info struct is correct.
56258 *
56259 * First off, we lookup the cast->type name to see if it is already loaded.
56260 * There are three cases to handle:
56261 * 1) If the cast->type has already been loaded AND the type we are adding
56262 * casting info to has not been loaded (it is in this module), THEN we
56263 * replace the cast->type pointer with the type pointer that has already
56264 * been loaded.
56265 * 2) If BOTH types (the one we are adding casting info to, and the
56266 * cast->type) are loaded, THEN the cast info has already been loaded by
56267 * the previous module so we just ignore it.
56268 * 3) Finally, if cast->type has not already been loaded, then we add that
56269 * swig_cast_info to the linked list (because the cast->type) pointer will
56270 * be correct.
56271 * ----------------------------------------------------------------------------- */
56272
56273 #ifdef __cplusplus
56274 extern "C" {
56275 #if 0
56276 } /* c-mode */
56277 #endif
56278 #endif
56279
56280 #if 0
56281 #define SWIGRUNTIME_DEBUG
56282 #endif
56283
56284 SWIGRUNTIME void
56285 SWIG_InitializeModule(void *clientdata) {
56286 size_t i;
56287 swig_module_info *module_head;
56288 static int init_run = 0;
56289
56290 clientdata = clientdata;
56291
56292 if (init_run) return;
56293 init_run = 1;
56294
56295 /* Initialize the swig_module */
56296 swig_module.type_initial = swig_type_initial;
56297 swig_module.cast_initial = swig_cast_initial;
56298
56299 /* Try and load any already created modules */
56300 module_head = SWIG_GetModule(clientdata);
56301 if (module_head) {
56302 swig_module.next = module_head->next;
56303 module_head->next = &swig_module;
56304 } else {
56305 /* This is the first module loaded */
56306 swig_module.next = &swig_module;
56307 SWIG_SetModule(clientdata, &swig_module);
56308 }
56309
56310 /* Now work on filling in swig_module.types */
56311 #ifdef SWIGRUNTIME_DEBUG
56312 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56313 #endif
56314 for (i = 0; i < swig_module.size; ++i) {
56315 swig_type_info *type = 0;
56316 swig_type_info *ret;
56317 swig_cast_info *cast;
56318
56319 #ifdef SWIGRUNTIME_DEBUG
56320 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56321 #endif
56322
56323 /* if there is another module already loaded */
56324 if (swig_module.next != &swig_module) {
56325 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56326 }
56327 if (type) {
56328 /* Overwrite clientdata field */
56329 #ifdef SWIGRUNTIME_DEBUG
56330 printf("SWIG_InitializeModule: found type %s\n", type->name);
56331 #endif
56332 if (swig_module.type_initial[i]->clientdata) {
56333 type->clientdata = swig_module.type_initial[i]->clientdata;
56334 #ifdef SWIGRUNTIME_DEBUG
56335 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56336 #endif
56337 }
56338 } else {
56339 type = swig_module.type_initial[i];
56340 }
56341
56342 /* Insert casting types */
56343 cast = swig_module.cast_initial[i];
56344 while (cast->type) {
56345 /* Don't need to add information already in the list */
56346 ret = 0;
56347 #ifdef SWIGRUNTIME_DEBUG
56348 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56349 #endif
56350 if (swig_module.next != &swig_module) {
56351 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56352 #ifdef SWIGRUNTIME_DEBUG
56353 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56354 #endif
56355 }
56356 if (ret) {
56357 if (type == swig_module.type_initial[i]) {
56358 #ifdef SWIGRUNTIME_DEBUG
56359 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56360 #endif
56361 cast->type = ret;
56362 ret = 0;
56363 } else {
56364 /* Check for casting already in the list */
56365 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56366 #ifdef SWIGRUNTIME_DEBUG
56367 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56368 #endif
56369 if (!ocast) ret = 0;
56370 }
56371 }
56372
56373 if (!ret) {
56374 #ifdef SWIGRUNTIME_DEBUG
56375 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56376 #endif
56377 if (type->cast) {
56378 type->cast->prev = cast;
56379 cast->next = type->cast;
56380 }
56381 type->cast = cast;
56382 }
56383 cast++;
56384 }
56385 /* Set entry in modules->types array equal to the type */
56386 swig_module.types[i] = type;
56387 }
56388 swig_module.types[i] = 0;
56389
56390 #ifdef SWIGRUNTIME_DEBUG
56391 printf("**** SWIG_InitializeModule: Cast List ******\n");
56392 for (i = 0; i < swig_module.size; ++i) {
56393 int j = 0;
56394 swig_cast_info *cast = swig_module.cast_initial[i];
56395 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56396 while (cast->type) {
56397 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56398 cast++;
56399 ++j;
56400 }
56401 printf("---- Total casts: %d\n",j);
56402 }
56403 printf("**** SWIG_InitializeModule: Cast List ******\n");
56404 #endif
56405 }
56406
56407 /* This function will propagate the clientdata field of type to
56408 * any new swig_type_info structures that have been added into the list
56409 * of equivalent types. It is like calling
56410 * SWIG_TypeClientData(type, clientdata) a second time.
56411 */
56412 SWIGRUNTIME void
56413 SWIG_PropagateClientData(void) {
56414 size_t i;
56415 swig_cast_info *equiv;
56416 static int init_run = 0;
56417
56418 if (init_run) return;
56419 init_run = 1;
56420
56421 for (i = 0; i < swig_module.size; i++) {
56422 if (swig_module.types[i]->clientdata) {
56423 equiv = swig_module.types[i]->cast;
56424 while (equiv) {
56425 if (!equiv->converter) {
56426 if (equiv->type && !equiv->type->clientdata)
56427 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56428 }
56429 equiv = equiv->next;
56430 }
56431 }
56432 }
56433 }
56434
56435 #ifdef __cplusplus
56436 #if 0
56437 {
56438 /* c-mode */
56439 #endif
56440 }
56441 #endif
56442
56443
56444
56445 #ifdef __cplusplus
56446 extern "C" {
56447 #endif
56448
56449 /* Python-specific SWIG API */
56450 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56451 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56452 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56453
56454 /* -----------------------------------------------------------------------------
56455 * global variable support code.
56456 * ----------------------------------------------------------------------------- */
56457
56458 typedef struct swig_globalvar {
56459 char *name; /* Name of global variable */
56460 PyObject *(*get_attr)(void); /* Return the current value */
56461 int (*set_attr)(PyObject *); /* Set the value */
56462 struct swig_globalvar *next;
56463 } swig_globalvar;
56464
56465 typedef struct swig_varlinkobject {
56466 PyObject_HEAD
56467 swig_globalvar *vars;
56468 } swig_varlinkobject;
56469
56470 SWIGINTERN PyObject *
56471 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56472 return PyString_FromString("<Swig global variables>");
56473 }
56474
56475 SWIGINTERN PyObject *
56476 swig_varlink_str(swig_varlinkobject *v) {
56477 PyObject *str = PyString_FromString("(");
56478 swig_globalvar *var;
56479 for (var = v->vars; var; var=var->next) {
56480 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56481 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56482 }
56483 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56484 return str;
56485 }
56486
56487 SWIGINTERN int
56488 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56489 PyObject *str = swig_varlink_str(v);
56490 fprintf(fp,"Swig global variables ");
56491 fprintf(fp,"%s\n", PyString_AsString(str));
56492 Py_DECREF(str);
56493 return 0;
56494 }
56495
56496 SWIGINTERN void
56497 swig_varlink_dealloc(swig_varlinkobject *v) {
56498 swig_globalvar *var = v->vars;
56499 while (var) {
56500 swig_globalvar *n = var->next;
56501 free(var->name);
56502 free(var);
56503 var = n;
56504 }
56505 }
56506
56507 SWIGINTERN PyObject *
56508 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56509 PyObject *res = NULL;
56510 swig_globalvar *var = v->vars;
56511 while (var) {
56512 if (strcmp(var->name,n) == 0) {
56513 res = (*var->get_attr)();
56514 break;
56515 }
56516 var = var->next;
56517 }
56518 if (res == NULL && !PyErr_Occurred()) {
56519 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56520 }
56521 return res;
56522 }
56523
56524 SWIGINTERN int
56525 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56526 int res = 1;
56527 swig_globalvar *var = v->vars;
56528 while (var) {
56529 if (strcmp(var->name,n) == 0) {
56530 res = (*var->set_attr)(p);
56531 break;
56532 }
56533 var = var->next;
56534 }
56535 if (res == 1 && !PyErr_Occurred()) {
56536 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56537 }
56538 return res;
56539 }
56540
56541 SWIGINTERN PyTypeObject*
56542 swig_varlink_type(void) {
56543 static char varlink__doc__[] = "Swig var link object";
56544 static PyTypeObject varlink_type;
56545 static int type_init = 0;
56546 if (!type_init) {
56547 const PyTypeObject tmp
56548 = {
56549 PyObject_HEAD_INIT(NULL)
56550 0, /* Number of items in variable part (ob_size) */
56551 (char *)"swigvarlink", /* Type name (tp_name) */
56552 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56553 0, /* Itemsize (tp_itemsize) */
56554 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56555 (printfunc) swig_varlink_print, /* Print (tp_print) */
56556 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56557 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56558 0, /* tp_compare */
56559 (reprfunc) swig_varlink_repr, /* tp_repr */
56560 0, /* tp_as_number */
56561 0, /* tp_as_sequence */
56562 0, /* tp_as_mapping */
56563 0, /* tp_hash */
56564 0, /* tp_call */
56565 (reprfunc)swig_varlink_str, /* tp_str */
56566 0, /* tp_getattro */
56567 0, /* tp_setattro */
56568 0, /* tp_as_buffer */
56569 0, /* tp_flags */
56570 varlink__doc__, /* tp_doc */
56571 0, /* tp_traverse */
56572 0, /* tp_clear */
56573 0, /* tp_richcompare */
56574 0, /* tp_weaklistoffset */
56575 #if PY_VERSION_HEX >= 0x02020000
56576 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56577 #endif
56578 #if PY_VERSION_HEX >= 0x02030000
56579 0, /* tp_del */
56580 #endif
56581 #ifdef COUNT_ALLOCS
56582 0,0,0,0 /* tp_alloc -> tp_next */
56583 #endif
56584 };
56585 varlink_type = tmp;
56586 varlink_type.ob_type = &PyType_Type;
56587 type_init = 1;
56588 }
56589 return &varlink_type;
56590 }
56591
56592 /* Create a variable linking object for use later */
56593 SWIGINTERN PyObject *
56594 SWIG_Python_newvarlink(void) {
56595 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56596 if (result) {
56597 result->vars = 0;
56598 }
56599 return ((PyObject*) result);
56600 }
56601
56602 SWIGINTERN void
56603 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56604 swig_varlinkobject *v = (swig_varlinkobject *) p;
56605 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56606 if (gv) {
56607 size_t size = strlen(name)+1;
56608 gv->name = (char *)malloc(size);
56609 if (gv->name) {
56610 strncpy(gv->name,name,size);
56611 gv->get_attr = get_attr;
56612 gv->set_attr = set_attr;
56613 gv->next = v->vars;
56614 }
56615 }
56616 v->vars = gv;
56617 }
56618
56619 SWIGINTERN PyObject *
56620 SWIG_globals() {
56621 static PyObject *_SWIG_globals = 0;
56622 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56623 return _SWIG_globals;
56624 }
56625
56626 /* -----------------------------------------------------------------------------
56627 * constants/methods manipulation
56628 * ----------------------------------------------------------------------------- */
56629
56630 /* Install Constants */
56631 SWIGINTERN void
56632 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56633 PyObject *obj = 0;
56634 size_t i;
56635 for (i = 0; constants[i].type; ++i) {
56636 switch(constants[i].type) {
56637 case SWIG_PY_POINTER:
56638 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56639 break;
56640 case SWIG_PY_BINARY:
56641 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56642 break;
56643 default:
56644 obj = 0;
56645 break;
56646 }
56647 if (obj) {
56648 PyDict_SetItemString(d, constants[i].name, obj);
56649 Py_DECREF(obj);
56650 }
56651 }
56652 }
56653
56654 /* -----------------------------------------------------------------------------*/
56655 /* Fix SwigMethods to carry the callback ptrs when needed */
56656 /* -----------------------------------------------------------------------------*/
56657
56658 SWIGINTERN void
56659 SWIG_Python_FixMethods(PyMethodDef *methods,
56660 swig_const_info *const_table,
56661 swig_type_info **types,
56662 swig_type_info **types_initial) {
56663 size_t i;
56664 for (i = 0; methods[i].ml_name; ++i) {
56665 const char *c = methods[i].ml_doc;
56666 if (c && (c = strstr(c, "swig_ptr: "))) {
56667 int j;
56668 swig_const_info *ci = 0;
56669 const char *name = c + 10;
56670 for (j = 0; const_table[j].type; ++j) {
56671 if (strncmp(const_table[j].name, name,
56672 strlen(const_table[j].name)) == 0) {
56673 ci = &(const_table[j]);
56674 break;
56675 }
56676 }
56677 if (ci) {
56678 size_t shift = (ci->ptype) - types;
56679 swig_type_info *ty = types_initial[shift];
56680 size_t ldoc = (c - methods[i].ml_doc);
56681 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56682 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56683 if (ndoc) {
56684 char *buff = ndoc;
56685 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56686 if (ptr) {
56687 strncpy(buff, methods[i].ml_doc, ldoc);
56688 buff += ldoc;
56689 strncpy(buff, "swig_ptr: ", 10);
56690 buff += 10;
56691 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56692 methods[i].ml_doc = ndoc;
56693 }
56694 }
56695 }
56696 }
56697 }
56698 }
56699
56700 #ifdef __cplusplus
56701 }
56702 #endif
56703
56704 /* -----------------------------------------------------------------------------*
56705 * Partial Init method
56706 * -----------------------------------------------------------------------------*/
56707
56708 #ifdef __cplusplus
56709 extern "C"
56710 #endif
56711 SWIGEXPORT void SWIG_init(void) {
56712 PyObject *m, *d;
56713
56714 /* Fix SwigMethods to carry the callback ptrs when needed */
56715 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56716
56717 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56718 d = PyModule_GetDict(m);
56719
56720 SWIG_InitializeModule(0);
56721 SWIG_InstallConstants(d,swig_const_table);
56722
56723
56724
56725 #ifndef wxPyUSE_EXPORT
56726 // Make our API structure a CObject so other modules can import it
56727 // from this module.
56728 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56729 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56730 Py_XDECREF(cobj);
56731 #endif
56732
56733 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56734 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56735 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56736 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56737 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56738 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56739 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56740 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56741 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56742 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56743 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56744 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56745 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56746 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56747 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56748 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56749 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56750 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56751 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56752 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56753 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56754 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56755 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56756 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56757 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56758 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56759 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56760 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56761 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56762 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56763 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56764 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56765 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56766 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56767 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56768 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56769 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56770 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56771 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56772 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56773 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56774 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56775 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56776 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56777 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56778 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56779 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56780 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56781 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56782 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56783 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56784 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56785 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56786 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56787 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56788 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56789 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56790 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56791 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56792 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56793 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56794 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56795 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56796 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56797 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56798 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56799 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56800 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56801 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56802 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56803 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56804 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56805 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56806 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56807 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56808 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56809 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56810 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56811 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56812 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56813 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56814 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56815 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56816 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56817 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56818 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56819 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56820 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56821 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56822 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56823 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56824 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56825 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56826 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56827 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56828 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56829 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56830 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56831 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56832 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56833 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56834 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56835 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56836 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56837 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56838 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56839 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56840 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56841 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56842 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56843 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56844 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56845 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56846 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56847 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56848 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56849 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56850 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56851 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56852 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56853 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56854 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56855 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56856 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56857 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56858 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56859 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56860 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56861 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56862 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56863 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56864 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56865 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56866 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56867 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56868 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56869 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56870 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56871 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56872 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56873 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56874 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56875 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56876 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56877 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56878 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56879 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56880 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56881 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56882 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56883 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56884 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56885 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56886 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56887 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56888 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56889 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56890 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56891 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56892 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56893 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56894 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56895 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56896 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56897 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56898 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56899 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56900 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56901 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56902 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56903 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56904 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56905 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56906 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56907 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56908 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56909 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56910 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56911 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56912 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56913 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56914 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56915 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56916 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56917 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56918 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56919 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56920 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56921 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56922 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56923 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56924 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56925 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56926 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56927 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56928 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56929 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56930 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56931 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56932 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56933 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56934 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56935 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56936 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56937 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56938 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56939 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56940 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56941 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56942 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56943 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56944 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56945 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56946 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56947 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56948 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56949 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56950 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56951 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56952 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56953 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56954 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56955 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56956 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56957 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56958 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56959 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56960 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56961 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56962 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56963 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56964 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56965 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56966 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56967 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56968 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56969 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56970 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56971 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56972 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56973 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56974 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56975 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56976 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56977 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56978 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56979 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56980 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56981 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56982 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56983 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56984 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56985 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56986 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56987 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56988 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56989 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56990 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56991 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56992 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56993 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56994 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56995 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56996 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56997 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56998 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56999 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57000 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57001 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57002 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57003 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57004 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57005 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57006 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57007 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57008 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57009 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57010 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57011 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57012 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57013 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57014 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57015 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57016 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57017 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57018 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57019 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57020 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57021 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57022 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57023 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57024 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57025 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57026 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57027 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57028 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57029 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57030 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57031 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57032 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57033 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57034 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57035 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57036 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57037 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57038 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57039 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57040 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57041 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57042 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57043 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57044 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57045 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57046 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57047 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57048 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57049 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57050 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57051 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57052 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57053 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57054 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57055 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57056 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57057 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57058 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57059 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57060 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57061 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57062 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57063 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57064 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57065 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57066 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57067 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57068 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57069 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57070 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57071 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57072 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57073 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57074 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57075 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57076 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57077 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57078 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57079 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57080 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57081 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57082 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57083 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57084 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57085 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57086 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57087 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57088 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57089 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57090 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57091 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57092 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57093 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57094 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57095 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57096 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57097 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57098 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57099 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57100 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57101 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57102 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57103 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57104 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57105 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57106 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57107 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57108 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57109 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57110 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57111 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57112 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57113 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57114 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57115 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57116 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57117 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57118 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57119 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57120 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57121 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57122 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57123 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57124 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57125 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57126 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57127 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57128 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57129 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57130 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57131 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57132 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57133 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57134 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57135 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57136 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57137 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57138 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57139 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57140 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57141 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57142 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57143 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57144 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57145 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57154 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57155 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57156 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57157 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57158 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57159 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57160 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57161 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57162 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57163 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57164 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57165 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57166 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57167 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57168 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57169 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57170 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57171 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57172 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57173 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57174 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57175 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57176 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57177 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57178 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57179 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57180 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57181 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57182 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57183 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57184 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57185 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57186 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57187 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57188 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57189 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57190 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57191 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57192 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57193 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57194 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57195 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57196 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57197 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57198 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57199 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57200 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57201 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57202 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57203 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57204 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57205 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57206 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57207 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57208 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57209 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57210 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57211 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57212 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57213 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57214 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57215 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57216 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57217 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57218 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57219 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57220 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57221 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57222 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57223 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57224 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57225 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57226 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57227 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57228 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57229 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57230 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57231 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57232 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57233 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57234 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57235 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57236 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57237 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57238 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57239 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57240 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57241 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57242 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57243 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57244 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57245 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57246 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57247 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57248 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57249 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57250 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57251 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57252 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57253 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57254 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57255 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57256 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57257 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57258 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57259 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57260 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57261 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57262 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57263 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57264 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57265 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57266 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57267 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57268 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57269 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57270 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57271 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57272 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57273 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57274 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57275 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57276 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57277 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57278 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57279 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57280 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57281 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57282 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57283 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57284 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57285 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57286 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57287 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57288 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57289 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57290 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57291 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57292 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57293 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57294 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57295 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57296 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57297 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57298 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57299 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57300 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57301 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57302 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57303 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57304 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57305 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57306 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57307 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57308 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57309 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57310 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57311 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57312 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57313 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57314 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57315 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57316 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57317 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57318 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57319 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57320 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57321 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57322 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57323 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57324 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57325 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57326 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57327 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57328 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57329 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57330 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57331 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57332 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57333 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57334 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57335 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57336 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57337 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57338 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57339 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57340 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57341 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57342 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57343 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57344 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57345 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57346 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57347 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57348 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57349 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57350 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57351 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57353 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57354 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57355 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57356 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57357 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57358 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57359 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57360 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57361 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57362 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57363 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57364 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57365 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57366 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57367 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57368 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57369 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57370 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57371 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57372 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57373 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57374 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57375 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57376 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57377 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57378 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57379 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57380 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57381 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57382 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57383 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57384 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57385 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57386 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57387 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57388 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57389
57390 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57391
57392
57393 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57394
57395 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57396 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57397 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57398 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57399 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57400 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57401 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57402 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57403 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57404 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57405 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57406 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57407 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57408 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57409 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57410 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57411 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57412 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57413 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57414 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57415 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57416 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57417 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57418 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57419 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57420 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57421 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57422 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57423 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57424 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57425 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57426 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57427 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57428 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57429 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57430 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57431 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57432 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57433 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57434 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57435 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57436 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57437 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57438 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57439 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57440 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57441 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57442 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57443 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57444 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57445 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57446 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57447 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57448 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57449 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57450 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57451 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57452 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57453 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57454 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57455 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57456 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57457 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57458 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57459 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57460 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57461 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57462 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57463 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57464 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57465 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57466 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57467 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57468 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57469 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57470 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57471 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57472 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57473 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57474 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57475 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57476 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57477 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57478 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57479 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57480 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57481 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57482 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57483 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57484 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57485 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57486 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57487 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57488 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57489 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57490 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57491 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57492 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57493 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57494 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57495 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57496 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57497 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57498 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57499 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57500 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57501 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57502 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57503 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57504 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57505 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57506 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57507 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57508 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57509 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57510 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57511 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57512 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57513 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57514 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57515 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57516 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57517 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57518 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57519 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57520 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57521 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57522 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57523 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57524 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57525 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57526 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57527 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57528 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57529 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57530 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57531 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57532 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57533 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57534 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57535 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57536 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57537 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57538 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57539 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57540 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57541 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57542 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57543 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57544 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57545 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57546 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57547 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57548 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57549 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57550 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57551 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57552 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57553 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57554 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57555 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57556 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57557 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57558 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57559 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57560 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57561 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57562 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57563 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57564 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57565 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57566 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57567 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57568 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57569 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57570 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57571 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57572 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57573 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57574 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57575 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57576 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57577 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57578 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57579 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57580 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57581 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57582 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57583 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57584 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57585 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57586 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57587 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57588 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57589 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57590 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57591 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57592 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57593 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57594 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57595 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57596 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57597 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57598 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57599 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57600 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57601 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57602 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57603 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57604 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57605 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57606 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57607
57608 // Initialize threading, some globals and such
57609 __wxPyPreStart(d);
57610
57611
57612 // Although these are defined in __version__ they need to be here too so
57613 // that an assert can be done to ensure that the wxPython and the wxWindows
57614 // versions match.
57615 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57616 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57617 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57618
57619 }
57620
wxWidgets (Impactor)