]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


3a61b2376de2a9914a7bf7bad55fba20d6247c1e
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3792 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3793 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3794 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3795 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3796 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3798 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3799 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3800 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3801 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3802 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3803 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3804 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3805 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3806 static const wxString wxPyControlNameStr(wxControlNameStr);
3807 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3808 if (clientData) {
3809 wxPyClientData* data = new wxPyClientData(clientData);
3810 return self->Append(item, data);
3811 } else
3812 return self->Append(item);
3813 }
3814 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3815 if (clientData) {
3816 wxPyClientData* data = new wxPyClientData(clientData);
3817 return self->Insert(item, pos, data);
3818 } else
3819 return self->Insert(item, pos);
3820 }
3821 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3822 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3823 if (data) {
3824 Py_INCREF(data->m_obj);
3825 return data->m_obj;
3826 } else {
3827 Py_INCREF(Py_None);
3828 return Py_None;
3829 }
3830 }
3831 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3832 wxPyClientData* data = new wxPyClientData(clientData);
3833 self->SetClientObject(n, data);
3834 }
3835
3836
3837 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3838 wxPyUserData* data = NULL;
3839 if ( userData ) {
3840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3841 data = new wxPyUserData(userData);
3842 wxPyEndBlockThreads(blocked);
3843 }
3844 return new wxSizerItem(window, proportion, flag, border, data);
3845 }
3846 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3847 wxPyUserData* data = NULL;
3848 if ( userData ) {
3849 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3850 data = new wxPyUserData(userData);
3851 wxPyEndBlockThreads(blocked);
3852 }
3853 return new wxSizerItem(width, height, proportion, flag, border, data);
3854 }
3855 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3856 wxPyUserData* data = NULL;
3857 if ( userData ) {
3858 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3859 data = new wxPyUserData(userData);
3860 wxPyEndBlockThreads(blocked);
3861 }
3862 return new wxSizerItem(sizer, proportion, flag, border, data);
3863 }
3864
3865 #include <float.h>
3866
3867
3868 SWIGINTERN int
3869 SWIG_AsVal_float (PyObject * obj, float *val)
3870 {
3871 double v;
3872 int res = SWIG_AsVal_double (obj, &v);
3873 if (SWIG_IsOK(res)) {
3874 if ((v < -FLT_MAX || v > FLT_MAX)) {
3875 return SWIG_OverflowError;
3876 } else {
3877 if (val) *val = static_cast< float >(v);
3878 }
3879 }
3880 return res;
3881 }
3882
3883
3884 SWIGINTERNINLINE PyObject *
3885 SWIG_From_float (float value)
3886 {
3887 return SWIG_From_double (value);
3888 }
3889
3890 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3891 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3892 if (data) {
3893 Py_INCREF(data->m_obj);
3894 return data->m_obj;
3895 } else {
3896 Py_INCREF(Py_None);
3897 return Py_None;
3898 }
3899 }
3900 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3901 wxPyUserData* data = NULL;
3902 if ( userData ) {
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 data = new wxPyUserData(userData);
3905 wxPyEndBlockThreads(blocked);
3906 }
3907 self->SetUserData(data);
3908 }
3909
3910 // Figure out the type of the sizer item
3911
3912 struct wxPySizerItemInfo {
3913 wxPySizerItemInfo()
3914 : window(NULL), sizer(NULL), gotSize(false),
3915 size(wxDefaultSize), gotPos(false), pos(-1)
3916 {}
3917
3918 wxWindow* window;
3919 wxSizer* sizer;
3920 bool gotSize;
3921 wxSize size;
3922 bool gotPos;
3923 int pos;
3924 };
3925
3926 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3927
3928 wxPySizerItemInfo info;
3929 wxSize size;
3930 wxSize* sizePtr = &size;
3931
3932 // Find out what the type of the item is
3933 // try wxWindow
3934 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3935 PyErr_Clear();
3936 info.window = NULL;
3937
3938 // try wxSizer
3939 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3940 PyErr_Clear();
3941 info.sizer = NULL;
3942
3943 // try wxSize or (w,h)
3944 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3945 info.size = *sizePtr;
3946 info.gotSize = true;
3947 }
3948
3949 // or a single int
3950 if (checkIdx && PyInt_Check(item)) {
3951 info.pos = PyInt_AsLong(item);
3952 info.gotPos = true;
3953 }
3954 }
3955 }
3956
3957 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3958 // no expected type, figure out what kind of error message to generate
3959 if ( !checkSize && !checkIdx )
3960 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3961 else if ( checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3963 else if ( !checkSize && checkIdx)
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3965 else
3966 // can this one happen?
3967 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3968 }
3969
3970 return info;
3971 }
3972
3973 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3974 if (!self->GetClientObject())
3975 self->SetClientObject(new wxPyOORClientData(_self));
3976 }
3977 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3978
3979 wxPyUserData* data = NULL;
3980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3982 if ( userData && (info.window || info.sizer || info.gotSize) )
3983 data = new wxPyUserData(userData);
3984 if ( info.sizer )
3985 PyObject_SetAttrString(item,"thisown",Py_False);
3986 wxPyEndBlockThreads(blocked);
3987
3988 // Now call the real Add method if a valid item type was found
3989 if ( info.window )
3990 return self->Add(info.window, proportion, flag, border, data);
3991 else if ( info.sizer )
3992 return self->Add(info.sizer, proportion, flag, border, data);
3993 else if (info.gotSize)
3994 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3995 proportion, flag, border, data);
3996 else
3997 return NULL;
3998 }
3999 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4000
4001 wxPyUserData* data = NULL;
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4004 if ( userData && (info.window || info.sizer || info.gotSize) )
4005 data = new wxPyUserData(userData);
4006 if ( info.sizer )
4007 PyObject_SetAttrString(item,"thisown",Py_False);
4008 wxPyEndBlockThreads(blocked);
4009
4010 // Now call the real Insert method if a valid item type was found
4011 if ( info.window )
4012 return self->Insert(before, info.window, proportion, flag, border, data);
4013 else if ( info.sizer )
4014 return self->Insert(before, info.sizer, proportion, flag, border, data);
4015 else if (info.gotSize)
4016 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4017 proportion, flag, border, data);
4018 else
4019 return NULL;
4020 }
4021 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4022
4023 wxPyUserData* data = NULL;
4024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4025 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4026 if ( userData && (info.window || info.sizer || info.gotSize) )
4027 data = new wxPyUserData(userData);
4028 if ( info.sizer )
4029 PyObject_SetAttrString(item,"thisown",Py_False);
4030 wxPyEndBlockThreads(blocked);
4031
4032 // Now call the real Prepend method if a valid item type was found
4033 if ( info.window )
4034 return self->Prepend(info.window, proportion, flag, border, data);
4035 else if ( info.sizer )
4036 return self->Prepend(info.sizer, proportion, flag, border, data);
4037 else if (info.gotSize)
4038 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4039 proportion, flag, border, data);
4040 else
4041 return NULL;
4042 }
4043 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4046 wxPyEndBlockThreads(blocked);
4047 if ( info.window )
4048 return self->Remove(info.window);
4049 else if ( info.sizer )
4050 return self->Remove(info.sizer);
4051 else if ( info.gotPos )
4052 return self->Remove(info.pos);
4053 else
4054 return false;
4055 }
4056 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4059 wxPyEndBlockThreads(blocked);
4060 if ( info.window )
4061 return self->Detach(info.window);
4062 else if ( info.sizer )
4063 return self->Detach(info.sizer);
4064 else if ( info.gotPos )
4065 return self->Detach(info.pos);
4066 else
4067 return false;
4068 }
4069 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4072 wxPyEndBlockThreads(blocked);
4073 if ( info.window )
4074 return self->GetItem(info.window);
4075 else if ( info.sizer )
4076 return self->GetItem(info.sizer);
4077 else if ( info.gotPos )
4078 return self->GetItem(info.pos);
4079 else
4080 return NULL;
4081 }
4082 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4085 wxPyEndBlockThreads(blocked);
4086 if ( info.window )
4087 self->SetItemMinSize(info.window, size);
4088 else if ( info.sizer )
4089 self->SetItemMinSize(info.sizer, size);
4090 else if ( info.gotPos )
4091 self->SetItemMinSize(info.pos, size);
4092 }
4093 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4094 wxSizerItemList& list = self->GetChildren();
4095 return wxPy_ConvertList(&list);
4096 }
4097 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4098 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4100 wxPyEndBlockThreads(blocked);
4101 if ( info.window )
4102 return self->Show(info.window, show, recursive);
4103 else if ( info.sizer )
4104 return self->Show(info.sizer, show, recursive);
4105 else if ( info.gotPos )
4106 return self->Show(info.pos, show);
4107 else
4108 return false;
4109 }
4110 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4113 wxPyEndBlockThreads(blocked);
4114 if ( info.window )
4115 return self->IsShown(info.window);
4116 else if ( info.sizer )
4117 return self->IsShown(info.sizer);
4118 else if ( info.gotPos )
4119 return self->IsShown(info.pos);
4120 else
4121 return false;
4122 }
4123
4124 // See pyclasses.h
4125 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4126 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4127 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4128
4129
4130
4131
4132 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4133 {
4134 if (source == Py_None) {
4135 **obj = wxGBPosition(-1,-1);
4136 return true;
4137 }
4138 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4139 }
4140
4141 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4142 {
4143 if (source == Py_None) {
4144 **obj = wxGBSpan(-1,-1);
4145 return true;
4146 }
4147 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4148 }
4149
4150
4151 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4152 self->SetRow(row);
4153 self->SetCol(col);
4154 }
4155 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4157 PyObject* tup = PyTuple_New(2);
4158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4160 wxPyEndBlockThreads(blocked);
4161 return tup;
4162 }
4163 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4164 self->SetRowspan(rowspan);
4165 self->SetColspan(colspan);
4166 }
4167 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 PyObject* tup = PyTuple_New(2);
4170 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4171 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4172 wxPyEndBlockThreads(blocked);
4173 return tup;
4174 }
4175 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4176 wxPyUserData* data = NULL;
4177 if ( userData ) {
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 data = new wxPyUserData(userData);
4180 wxPyEndBlockThreads(blocked);
4181 }
4182 return new wxGBSizerItem(window, pos, span, flag, border, data);
4183 }
4184 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4185 wxPyUserData* data = NULL;
4186 if ( userData ) {
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 data = new wxPyUserData(userData);
4189 wxPyEndBlockThreads(blocked);
4190 }
4191 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4192 }
4193 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4194 wxPyUserData* data = NULL;
4195 if ( userData ) {
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 data = new wxPyUserData(userData);
4198 wxPyEndBlockThreads(blocked);
4199 }
4200 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4201 }
4202 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4203 int row, col;
4204 self->GetEndPos(row, col);
4205 return wxGBPosition(row, col);
4206 }
4207 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4208
4209 wxPyUserData* data = NULL;
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4212 if ( userData && (info.window || info.sizer || info.gotSize) )
4213 data = new wxPyUserData(userData);
4214 if ( info.sizer )
4215 PyObject_SetAttrString(item,"thisown",Py_False);
4216 wxPyEndBlockThreads(blocked);
4217
4218 // Now call the real Add method if a valid item type was found
4219 if ( info.window )
4220 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4221 else if ( info.sizer )
4222 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4223 else if (info.gotSize)
4224 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4225 pos, span, flag, border, data);
4226 return NULL;
4227 }
4228
4229
4230 #ifdef __cplusplus
4231 extern "C" {
4232 #endif
4233 SWIGINTERN int EmptyString_set(PyObject *) {
4234 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4235 return 1;
4236 }
4237
4238
4239 SWIGINTERN PyObject *EmptyString_get(void) {
4240 PyObject *pyobj = 0;
4241
4242 {
4243 #if wxUSE_UNICODE
4244 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4245 #else
4246 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #endif
4248 }
4249 return pyobj;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254 PyObject *resultobj = 0;
4255 wxObject *arg1 = (wxObject *) 0 ;
4256 wxString result;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 PyObject *swig_obj[1] ;
4260
4261 if (!args) SWIG_fail;
4262 swig_obj[0] = args;
4263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4264 if (!SWIG_IsOK(res1)) {
4265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4266 }
4267 arg1 = reinterpret_cast< wxObject * >(argp1);
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxObject_GetClassName(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 {
4275 #if wxUSE_UNICODE
4276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4277 #else
4278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4279 #endif
4280 }
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4288 PyObject *resultobj = 0;
4289 wxObject *arg1 = (wxObject *) 0 ;
4290 void *argp1 = 0 ;
4291 int res1 = 0 ;
4292 PyObject *swig_obj[1] ;
4293
4294 if (!args) SWIG_fail;
4295 swig_obj[0] = args;
4296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4299 }
4300 arg1 = reinterpret_cast< wxObject * >(argp1);
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 wxObject_Destroy(arg1);
4304 wxPyEndAllowThreads(__tstate);
4305 if (PyErr_Occurred()) SWIG_fail;
4306 }
4307 resultobj = SWIG_Py_Void();
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *obj;
4316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4317 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4318 return SWIG_Py_Void();
4319 }
4320
4321 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4322 PyObject *resultobj = 0;
4323 wxSize *arg1 = (wxSize *) 0 ;
4324 int arg2 ;
4325 void *argp1 = 0 ;
4326 int res1 = 0 ;
4327 int val2 ;
4328 int ecode2 = 0 ;
4329 PyObject *swig_obj[2] ;
4330
4331 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4333 if (!SWIG_IsOK(res1)) {
4334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4335 }
4336 arg1 = reinterpret_cast< wxSize * >(argp1);
4337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4338 if (!SWIG_IsOK(ecode2)) {
4339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4340 }
4341 arg2 = static_cast< int >(val2);
4342 if (arg1) (arg1)->x = arg2;
4343
4344 resultobj = SWIG_Py_Void();
4345 return resultobj;
4346 fail:
4347 return NULL;
4348 }
4349
4350
4351 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4352 PyObject *resultobj = 0;
4353 wxSize *arg1 = (wxSize *) 0 ;
4354 int result;
4355 void *argp1 = 0 ;
4356 int res1 = 0 ;
4357 PyObject *swig_obj[1] ;
4358
4359 if (!args) SWIG_fail;
4360 swig_obj[0] = args;
4361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4362 if (!SWIG_IsOK(res1)) {
4363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4364 }
4365 arg1 = reinterpret_cast< wxSize * >(argp1);
4366 result = (int) ((arg1)->x);
4367 resultobj = SWIG_From_int(static_cast< int >(result));
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4375 PyObject *resultobj = 0;
4376 wxSize *arg1 = (wxSize *) 0 ;
4377 int arg2 ;
4378 void *argp1 = 0 ;
4379 int res1 = 0 ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject *swig_obj[2] ;
4383
4384 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4386 if (!SWIG_IsOK(res1)) {
4387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4388 }
4389 arg1 = reinterpret_cast< wxSize * >(argp1);
4390 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4391 if (!SWIG_IsOK(ecode2)) {
4392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4393 }
4394 arg2 = static_cast< int >(val2);
4395 if (arg1) (arg1)->y = arg2;
4396
4397 resultobj = SWIG_Py_Void();
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405 PyObject *resultobj = 0;
4406 wxSize *arg1 = (wxSize *) 0 ;
4407 int result;
4408 void *argp1 = 0 ;
4409 int res1 = 0 ;
4410 PyObject *swig_obj[1] ;
4411
4412 if (!args) SWIG_fail;
4413 swig_obj[0] = args;
4414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4415 if (!SWIG_IsOK(res1)) {
4416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4417 }
4418 arg1 = reinterpret_cast< wxSize * >(argp1);
4419 result = (int) ((arg1)->y);
4420 resultobj = SWIG_From_int(static_cast< int >(result));
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 int arg1 = (int) 0 ;
4430 int arg2 = (int) 0 ;
4431 wxSize *result = 0 ;
4432 int val1 ;
4433 int ecode1 = 0 ;
4434 int val2 ;
4435 int ecode2 = 0 ;
4436 PyObject * obj0 = 0 ;
4437 PyObject * obj1 = 0 ;
4438 char * kwnames[] = {
4439 (char *) "w",(char *) "h", NULL
4440 };
4441
4442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4443 if (obj0) {
4444 ecode1 = SWIG_AsVal_int(obj0, &val1);
4445 if (!SWIG_IsOK(ecode1)) {
4446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4447 }
4448 arg1 = static_cast< int >(val1);
4449 }
4450 if (obj1) {
4451 ecode2 = SWIG_AsVal_int(obj1, &val2);
4452 if (!SWIG_IsOK(ecode2)) {
4453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4454 }
4455 arg2 = static_cast< int >(val2);
4456 }
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = (wxSize *)new wxSize(arg1,arg2);
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4471 PyObject *resultobj = 0;
4472 wxSize *arg1 = (wxSize *) 0 ;
4473 void *argp1 = 0 ;
4474 int res1 = 0 ;
4475 PyObject *swig_obj[1] ;
4476
4477 if (!args) SWIG_fail;
4478 swig_obj[0] = args;
4479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4480 if (!SWIG_IsOK(res1)) {
4481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4482 }
4483 arg1 = reinterpret_cast< wxSize * >(argp1);
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 resultobj = SWIG_Py_Void();
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 wxSize *arg2 = 0 ;
4502 bool result;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 wxSize temp2 ;
4506 PyObject * obj0 = 0 ;
4507 PyObject * obj1 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "self",(char *) "sz", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4516 }
4517 arg1 = reinterpret_cast< wxSize * >(argp1);
4518 {
4519 arg2 = &temp2;
4520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4521 }
4522 {
4523 PyThreadState* __tstate = wxPyBeginAllowThreads();
4524 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4525 wxPyEndAllowThreads(__tstate);
4526 if (PyErr_Occurred()) SWIG_fail;
4527 }
4528 {
4529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4530 }
4531 return resultobj;
4532 fail:
4533 return NULL;
4534 }
4535
4536
4537 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4538 PyObject *resultobj = 0;
4539 wxSize *arg1 = (wxSize *) 0 ;
4540 wxSize *arg2 = 0 ;
4541 bool result;
4542 void *argp1 = 0 ;
4543 int res1 = 0 ;
4544 wxSize temp2 ;
4545 PyObject * obj0 = 0 ;
4546 PyObject * obj1 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "self",(char *) "sz", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4553 if (!SWIG_IsOK(res1)) {
4554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4555 }
4556 arg1 = reinterpret_cast< wxSize * >(argp1);
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4569 }
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = 0;
4578 wxSize *arg1 = (wxSize *) 0 ;
4579 wxSize *arg2 = 0 ;
4580 wxSize result;
4581 void *argp1 = 0 ;
4582 int res1 = 0 ;
4583 wxSize temp2 ;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char * kwnames[] = {
4587 (char *) "self",(char *) "sz", NULL
4588 };
4589
4590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4592 if (!SWIG_IsOK(res1)) {
4593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4594 }
4595 arg1 = reinterpret_cast< wxSize * >(argp1);
4596 {
4597 arg2 = &temp2;
4598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4599 }
4600 {
4601 PyThreadState* __tstate = wxPyBeginAllowThreads();
4602 result = (arg1)->operator +((wxSize const &)*arg2);
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj = 0;
4615 wxSize *arg1 = (wxSize *) 0 ;
4616 wxSize *arg2 = 0 ;
4617 wxSize result;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 wxSize temp2 ;
4621 PyObject * obj0 = 0 ;
4622 PyObject * obj1 = 0 ;
4623 char * kwnames[] = {
4624 (char *) "self",(char *) "sz", NULL
4625 };
4626
4627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4629 if (!SWIG_IsOK(res1)) {
4630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4631 }
4632 arg1 = reinterpret_cast< wxSize * >(argp1);
4633 {
4634 arg2 = &temp2;
4635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4636 }
4637 {
4638 PyThreadState* __tstate = wxPyBeginAllowThreads();
4639 result = (arg1)->operator -((wxSize const &)*arg2);
4640 wxPyEndAllowThreads(__tstate);
4641 if (PyErr_Occurred()) SWIG_fail;
4642 }
4643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4644 return resultobj;
4645 fail:
4646 return NULL;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj = 0;
4652 wxSize *arg1 = (wxSize *) 0 ;
4653 wxSize *arg2 = 0 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 wxSize temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char * kwnames[] = {
4660 (char *) "self",(char *) "sz", NULL
4661 };
4662
4663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4665 if (!SWIG_IsOK(res1)) {
4666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4667 }
4668 arg1 = reinterpret_cast< wxSize * >(argp1);
4669 {
4670 arg2 = &temp2;
4671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4672 }
4673 {
4674 PyThreadState* __tstate = wxPyBeginAllowThreads();
4675 (arg1)->IncTo((wxSize const &)*arg2);
4676 wxPyEndAllowThreads(__tstate);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 resultobj = SWIG_Py_Void();
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
4686 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4687 PyObject *resultobj = 0;
4688 wxSize *arg1 = (wxSize *) 0 ;
4689 wxSize *arg2 = 0 ;
4690 void *argp1 = 0 ;
4691 int res1 = 0 ;
4692 wxSize temp2 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 char * kwnames[] = {
4696 (char *) "self",(char *) "sz", NULL
4697 };
4698
4699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4701 if (!SWIG_IsOK(res1)) {
4702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4703 }
4704 arg1 = reinterpret_cast< wxSize * >(argp1);
4705 {
4706 arg2 = &temp2;
4707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4708 }
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 (arg1)->DecTo((wxSize const &)*arg2);
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_Py_Void();
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 wxSize *arg1 = (wxSize *) 0 ;
4725 int arg2 ;
4726 int arg3 ;
4727 void *argp1 = 0 ;
4728 int res1 = 0 ;
4729 int val2 ;
4730 int ecode2 = 0 ;
4731 int val3 ;
4732 int ecode3 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 PyObject * obj2 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "w",(char *) "h", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 ecode2 = SWIG_AsVal_int(obj1, &val2);
4747 if (!SWIG_IsOK(ecode2)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4749 }
4750 arg2 = static_cast< int >(val2);
4751 ecode3 = SWIG_AsVal_int(obj2, &val3);
4752 if (!SWIG_IsOK(ecode3)) {
4753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4754 }
4755 arg3 = static_cast< int >(val3);
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 (arg1)->Set(arg2,arg3);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = SWIG_Py_Void();
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4770 PyObject *resultobj = 0;
4771 wxSize *arg1 = (wxSize *) 0 ;
4772 int arg2 ;
4773 void *argp1 = 0 ;
4774 int res1 = 0 ;
4775 int val2 ;
4776 int ecode2 = 0 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char * kwnames[] = {
4780 (char *) "self",(char *) "w", NULL
4781 };
4782
4783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4785 if (!SWIG_IsOK(res1)) {
4786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4787 }
4788 arg1 = reinterpret_cast< wxSize * >(argp1);
4789 ecode2 = SWIG_AsVal_int(obj1, &val2);
4790 if (!SWIG_IsOK(ecode2)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4792 }
4793 arg2 = static_cast< int >(val2);
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 (arg1)->SetWidth(arg2);
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 resultobj = SWIG_Py_Void();
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 int arg2 ;
4811 void *argp1 = 0 ;
4812 int res1 = 0 ;
4813 int val2 ;
4814 int ecode2 = 0 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "h", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 ecode2 = SWIG_AsVal_int(obj1, &val2);
4828 if (!SWIG_IsOK(ecode2)) {
4829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4830 }
4831 arg2 = static_cast< int >(val2);
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 (arg1)->SetHeight(arg2);
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847 wxSize *arg1 = (wxSize *) 0 ;
4848 int result;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 PyObject *swig_obj[1] ;
4852
4853 if (!args) SWIG_fail;
4854 swig_obj[0] = args;
4855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4858 }
4859 arg1 = reinterpret_cast< wxSize * >(argp1);
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (int)((wxSize const *)arg1)->GetWidth();
4863 wxPyEndAllowThreads(__tstate);
4864 if (PyErr_Occurred()) SWIG_fail;
4865 }
4866 resultobj = SWIG_From_int(static_cast< int >(result));
4867 return resultobj;
4868 fail:
4869 return NULL;
4870 }
4871
4872
4873 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4874 PyObject *resultobj = 0;
4875 wxSize *arg1 = (wxSize *) 0 ;
4876 int result;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 PyObject *swig_obj[1] ;
4880
4881 if (!args) SWIG_fail;
4882 swig_obj[0] = args;
4883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4884 if (!SWIG_IsOK(res1)) {
4885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4886 }
4887 arg1 = reinterpret_cast< wxSize * >(argp1);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (int)((wxSize const *)arg1)->GetHeight();
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_From_int(static_cast< int >(result));
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 bool result;
4905 void *argp1 = 0 ;
4906 int res1 = 0 ;
4907 PyObject *swig_obj[1] ;
4908
4909 if (!args) SWIG_fail;
4910 swig_obj[0] = args;
4911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 {
4923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4924 }
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 wxSize *arg2 = 0 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 wxSize temp2 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "size", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 {
4951 arg2 = &temp2;
4952 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4953 }
4954 {
4955 PyThreadState* __tstate = wxPyBeginAllowThreads();
4956 (arg1)->SetDefaults((wxSize const &)*arg2);
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4968 PyObject *resultobj = 0;
4969 wxSize *arg1 = (wxSize *) 0 ;
4970 PyObject *result = 0 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 PyObject *swig_obj[1] ;
4974
4975 if (!args) SWIG_fail;
4976 swig_obj[0] = args;
4977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4978 if (!SWIG_IsOK(res1)) {
4979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4980 }
4981 arg1 = reinterpret_cast< wxSize * >(argp1);
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 result = (PyObject *)wxSize_Get(arg1);
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = result;
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996 PyObject *obj;
4997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4998 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
4999 return SWIG_Py_Void();
5000 }
5001
5002 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003 return SWIG_Python_InitShadowInstance(args);
5004 }
5005
5006 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 PyObject *resultobj = 0;
5008 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5009 double arg2 ;
5010 void *argp1 = 0 ;
5011 int res1 = 0 ;
5012 double val2 ;
5013 int ecode2 = 0 ;
5014 PyObject *swig_obj[2] ;
5015
5016 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5020 }
5021 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5022 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5025 }
5026 arg2 = static_cast< double >(val2);
5027 if (arg1) (arg1)->x = arg2;
5028
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5037 PyObject *resultobj = 0;
5038 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5039 double result;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 PyObject *swig_obj[1] ;
5043
5044 if (!args) SWIG_fail;
5045 swig_obj[0] = args;
5046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5049 }
5050 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5051 result = (double) ((arg1)->x);
5052 resultobj = SWIG_From_double(static_cast< double >(result));
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060 PyObject *resultobj = 0;
5061 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5062 double arg2 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 double val2 ;
5066 int ecode2 = 0 ;
5067 PyObject *swig_obj[2] ;
5068
5069 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5071 if (!SWIG_IsOK(res1)) {
5072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5073 }
5074 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5075 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5076 if (!SWIG_IsOK(ecode2)) {
5077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5078 }
5079 arg2 = static_cast< double >(val2);
5080 if (arg1) (arg1)->y = arg2;
5081
5082 resultobj = SWIG_Py_Void();
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5090 PyObject *resultobj = 0;
5091 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5092 double result;
5093 void *argp1 = 0 ;
5094 int res1 = 0 ;
5095 PyObject *swig_obj[1] ;
5096
5097 if (!args) SWIG_fail;
5098 swig_obj[0] = args;
5099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5102 }
5103 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5104 result = (double) ((arg1)->y);
5105 resultobj = SWIG_From_double(static_cast< double >(result));
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj = 0;
5114 double arg1 = (double) 0.0 ;
5115 double arg2 = (double) 0.0 ;
5116 wxRealPoint *result = 0 ;
5117 double val1 ;
5118 int ecode1 = 0 ;
5119 double val2 ;
5120 int ecode2 = 0 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "x",(char *) "y", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5128 if (obj0) {
5129 ecode1 = SWIG_AsVal_double(obj0, &val1);
5130 if (!SWIG_IsOK(ecode1)) {
5131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5132 }
5133 arg1 = static_cast< double >(val1);
5134 }
5135 if (obj1) {
5136 ecode2 = SWIG_AsVal_double(obj1, &val2);
5137 if (!SWIG_IsOK(ecode2)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5139 }
5140 arg2 = static_cast< double >(val2);
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5156 PyObject *resultobj = 0;
5157 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5158 void *argp1 = 0 ;
5159 int res1 = 0 ;
5160 PyObject *swig_obj[1] ;
5161
5162 if (!args) SWIG_fail;
5163 swig_obj[0] = args;
5164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5167 }
5168 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 delete arg1;
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 resultobj = SWIG_Py_Void();
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj = 0;
5185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5186 wxRealPoint *arg2 = 0 ;
5187 bool result;
5188 void *argp1 = 0 ;
5189 int res1 = 0 ;
5190 wxRealPoint temp2 ;
5191 PyObject * obj0 = 0 ;
5192 PyObject * obj1 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "self",(char *) "pt", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 {
5204 arg2 = &temp2;
5205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5206 }
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5225 wxRealPoint *arg2 = 0 ;
5226 bool result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 wxRealPoint temp2 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "self",(char *) "pt", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5238 if (!SWIG_IsOK(res1)) {
5239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5240 }
5241 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5242 {
5243 arg2 = &temp2;
5244 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5245 }
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 {
5253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5254 }
5255 return resultobj;
5256 fail:
5257 return NULL;
5258 }
5259
5260
5261 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5262 PyObject *resultobj = 0;
5263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5264 wxRealPoint *arg2 = 0 ;
5265 wxRealPoint result;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxRealPoint temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "pt", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5279 }
5280 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj = 0;
5300 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5301 wxRealPoint *arg2 = 0 ;
5302 wxRealPoint result;
5303 void *argp1 = 0 ;
5304 int res1 = 0 ;
5305 wxRealPoint temp2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char * kwnames[] = {
5309 (char *) "self",(char *) "pt", NULL
5310 };
5311
5312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5316 }
5317 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5318 {
5319 arg2 = &temp2;
5320 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj = 0;
5337 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5338 double arg2 ;
5339 double arg3 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 double val2 ;
5343 int ecode2 = 0 ;
5344 double val3 ;
5345 int ecode3 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 PyObject * obj2 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "self",(char *) "x",(char *) "y", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5355 if (!SWIG_IsOK(res1)) {
5356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5357 }
5358 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5359 ecode2 = SWIG_AsVal_double(obj1, &val2);
5360 if (!SWIG_IsOK(ecode2)) {
5361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5362 }
5363 arg2 = static_cast< double >(val2);
5364 ecode3 = SWIG_AsVal_double(obj2, &val3);
5365 if (!SWIG_IsOK(ecode3)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5367 }
5368 arg3 = static_cast< double >(val3);
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 wxRealPoint_Set(arg1,arg2,arg3);
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 resultobj = SWIG_Py_Void();
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5383 PyObject *resultobj = 0;
5384 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5385 PyObject *result = 0 ;
5386 void *argp1 = 0 ;
5387 int res1 = 0 ;
5388 PyObject *swig_obj[1] ;
5389
5390 if (!args) SWIG_fail;
5391 swig_obj[0] = args;
5392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (PyObject *)wxRealPoint_Get(arg1);
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 resultobj = result;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411 PyObject *obj;
5412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5413 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5414 return SWIG_Py_Void();
5415 }
5416
5417 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 return SWIG_Python_InitShadowInstance(args);
5419 }
5420
5421 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *resultobj = 0;
5423 wxPoint *arg1 = (wxPoint *) 0 ;
5424 int arg2 ;
5425 void *argp1 = 0 ;
5426 int res1 = 0 ;
5427 int val2 ;
5428 int ecode2 = 0 ;
5429 PyObject *swig_obj[2] ;
5430
5431 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5435 }
5436 arg1 = reinterpret_cast< wxPoint * >(argp1);
5437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5438 if (!SWIG_IsOK(ecode2)) {
5439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5440 }
5441 arg2 = static_cast< int >(val2);
5442 if (arg1) (arg1)->x = arg2;
5443
5444 resultobj = SWIG_Py_Void();
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5452 PyObject *resultobj = 0;
5453 wxPoint *arg1 = (wxPoint *) 0 ;
5454 int result;
5455 void *argp1 = 0 ;
5456 int res1 = 0 ;
5457 PyObject *swig_obj[1] ;
5458
5459 if (!args) SWIG_fail;
5460 swig_obj[0] = args;
5461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5464 }
5465 arg1 = reinterpret_cast< wxPoint * >(argp1);
5466 result = (int) ((arg1)->x);
5467 resultobj = SWIG_From_int(static_cast< int >(result));
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5475 PyObject *resultobj = 0;
5476 wxPoint *arg1 = (wxPoint *) 0 ;
5477 int arg2 ;
5478 void *argp1 = 0 ;
5479 int res1 = 0 ;
5480 int val2 ;
5481 int ecode2 = 0 ;
5482 PyObject *swig_obj[2] ;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxPoint * >(argp1);
5490 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5491 if (!SWIG_IsOK(ecode2)) {
5492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5493 }
5494 arg2 = static_cast< int >(val2);
5495 if (arg1) (arg1)->y = arg2;
5496
5497 resultobj = SWIG_Py_Void();
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxPoint *arg1 = (wxPoint *) 0 ;
5507 int result;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 PyObject *swig_obj[1] ;
5511
5512 if (!args) SWIG_fail;
5513 swig_obj[0] = args;
5514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5515 if (!SWIG_IsOK(res1)) {
5516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5517 }
5518 arg1 = reinterpret_cast< wxPoint * >(argp1);
5519 result = (int) ((arg1)->y);
5520 resultobj = SWIG_From_int(static_cast< int >(result));
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj = 0;
5529 int arg1 = (int) 0 ;
5530 int arg2 = (int) 0 ;
5531 wxPoint *result = 0 ;
5532 int val1 ;
5533 int ecode1 = 0 ;
5534 int val2 ;
5535 int ecode2 = 0 ;
5536 PyObject * obj0 = 0 ;
5537 PyObject * obj1 = 0 ;
5538 char * kwnames[] = {
5539 (char *) "x",(char *) "y", NULL
5540 };
5541
5542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5543 if (obj0) {
5544 ecode1 = SWIG_AsVal_int(obj0, &val1);
5545 if (!SWIG_IsOK(ecode1)) {
5546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5547 }
5548 arg1 = static_cast< int >(val1);
5549 }
5550 if (obj1) {
5551 ecode2 = SWIG_AsVal_int(obj1, &val2);
5552 if (!SWIG_IsOK(ecode2)) {
5553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5554 }
5555 arg2 = static_cast< int >(val2);
5556 }
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = (wxPoint *)new wxPoint(arg1,arg2);
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxPoint *arg1 = (wxPoint *) 0 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 PyObject *swig_obj[1] ;
5576
5577 if (!args) SWIG_fail;
5578 swig_obj[0] = args;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxPoint * >(argp1);
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 delete arg1;
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_Py_Void();
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxPoint *arg1 = (wxPoint *) 0 ;
5601 wxPoint *arg2 = 0 ;
5602 bool result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 wxPoint temp2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "self",(char *) "pt", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5614 if (!SWIG_IsOK(res1)) {
5615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5616 }
5617 arg1 = reinterpret_cast< wxPoint * >(argp1);
5618 {
5619 arg2 = &temp2;
5620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5621 }
5622 {
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 wxPoint *arg2 = 0 ;
5641 bool result;
5642 void *argp1 = 0 ;
5643 int res1 = 0 ;
5644 wxPoint temp2 ;
5645 PyObject * obj0 = 0 ;
5646 PyObject * obj1 = 0 ;
5647 char * kwnames[] = {
5648 (char *) "self",(char *) "pt", NULL
5649 };
5650
5651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 {
5658 arg2 = &temp2;
5659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 {
5668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 wxPoint *arg2 = 0 ;
5680 wxPoint result;
5681 void *argp1 = 0 ;
5682 int res1 = 0 ;
5683 wxPoint temp2 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char * kwnames[] = {
5687 (char *) "self",(char *) "pt", NULL
5688 };
5689
5690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5692 if (!SWIG_IsOK(res1)) {
5693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5694 }
5695 arg1 = reinterpret_cast< wxPoint * >(argp1);
5696 {
5697 arg2 = &temp2;
5698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5699 }
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 result = (arg1)->operator +((wxPoint const &)*arg2);
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj = 0;
5715 wxPoint *arg1 = (wxPoint *) 0 ;
5716 wxPoint *arg2 = 0 ;
5717 wxPoint result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 wxPoint temp2 ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char * kwnames[] = {
5724 (char *) "self",(char *) "pt", NULL
5725 };
5726
5727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5729 if (!SWIG_IsOK(res1)) {
5730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5731 }
5732 arg1 = reinterpret_cast< wxPoint * >(argp1);
5733 {
5734 arg2 = &temp2;
5735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (arg1)->operator -((wxPoint const &)*arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = 0;
5752 wxPoint *arg1 = (wxPoint *) 0 ;
5753 wxPoint *arg2 = 0 ;
5754 wxPoint *result = 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 wxPoint temp2 ;
5758 PyObject * obj0 = 0 ;
5759 PyObject * obj1 = 0 ;
5760 char * kwnames[] = {
5761 (char *) "self",(char *) "pt", NULL
5762 };
5763
5764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5766 if (!SWIG_IsOK(res1)) {
5767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5768 }
5769 arg1 = reinterpret_cast< wxPoint * >(argp1);
5770 {
5771 arg2 = &temp2;
5772 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 {
5777 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5778 result = (wxPoint *) &_result_ref;
5779 }
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 wxPoint *arg1 = (wxPoint *) 0 ;
5793 wxPoint *arg2 = 0 ;
5794 wxPoint *result = 0 ;
5795 void *argp1 = 0 ;
5796 int res1 = 0 ;
5797 wxPoint temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "self",(char *) "pt", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5808 }
5809 arg1 = reinterpret_cast< wxPoint * >(argp1);
5810 {
5811 arg2 = &temp2;
5812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5813 }
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 {
5817 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5818 result = (wxPoint *) &_result_ref;
5819 }
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 wxPoint *arg1 = (wxPoint *) 0 ;
5833 long arg2 ;
5834 long arg3 ;
5835 void *argp1 = 0 ;
5836 int res1 = 0 ;
5837 long val2 ;
5838 int ecode2 = 0 ;
5839 long val3 ;
5840 int ecode3 = 0 ;
5841 PyObject * obj0 = 0 ;
5842 PyObject * obj1 = 0 ;
5843 PyObject * obj2 = 0 ;
5844 char * kwnames[] = {
5845 (char *) "self",(char *) "x",(char *) "y", NULL
5846 };
5847
5848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5850 if (!SWIG_IsOK(res1)) {
5851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5852 }
5853 arg1 = reinterpret_cast< wxPoint * >(argp1);
5854 ecode2 = SWIG_AsVal_long(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5857 }
5858 arg2 = static_cast< long >(val2);
5859 ecode3 = SWIG_AsVal_long(obj2, &val3);
5860 if (!SWIG_IsOK(ecode3)) {
5861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5862 }
5863 arg3 = static_cast< long >(val3);
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 wxPoint_Set(arg1,arg2,arg3);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *result = 0 ;
5881 void *argp1 = 0 ;
5882 int res1 = 0 ;
5883 PyObject *swig_obj[1] ;
5884
5885 if (!args) SWIG_fail;
5886 swig_obj[0] = args;
5887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5888 if (!SWIG_IsOK(res1)) {
5889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5890 }
5891 arg1 = reinterpret_cast< wxPoint * >(argp1);
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (PyObject *)wxPoint_Get(arg1);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = result;
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5906 PyObject *obj;
5907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5908 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5909 return SWIG_Py_Void();
5910 }
5911
5912 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5913 return SWIG_Python_InitShadowInstance(args);
5914 }
5915
5916 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj = 0;
5918 int arg1 = (int) 0 ;
5919 int arg2 = (int) 0 ;
5920 int arg3 = (int) 0 ;
5921 int arg4 = (int) 0 ;
5922 wxRect *result = 0 ;
5923 int val1 ;
5924 int ecode1 = 0 ;
5925 int val2 ;
5926 int ecode2 = 0 ;
5927 int val3 ;
5928 int ecode3 = 0 ;
5929 int val4 ;
5930 int ecode4 = 0 ;
5931 PyObject * obj0 = 0 ;
5932 PyObject * obj1 = 0 ;
5933 PyObject * obj2 = 0 ;
5934 PyObject * obj3 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5940 if (obj0) {
5941 ecode1 = SWIG_AsVal_int(obj0, &val1);
5942 if (!SWIG_IsOK(ecode1)) {
5943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5944 }
5945 arg1 = static_cast< int >(val1);
5946 }
5947 if (obj1) {
5948 ecode2 = SWIG_AsVal_int(obj1, &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5951 }
5952 arg2 = static_cast< int >(val2);
5953 }
5954 if (obj2) {
5955 ecode3 = SWIG_AsVal_int(obj2, &val3);
5956 if (!SWIG_IsOK(ecode3)) {
5957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5958 }
5959 arg3 = static_cast< int >(val3);
5960 }
5961 if (obj3) {
5962 ecode4 = SWIG_AsVal_int(obj3, &val4);
5963 if (!SWIG_IsOK(ecode4)) {
5964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5965 }
5966 arg4 = static_cast< int >(val4);
5967 }
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = 0 ;
5984 wxPoint *arg2 = 0 ;
5985 wxRect *result = 0 ;
5986 wxPoint temp1 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "topLeft",(char *) "bottomRight", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5995 {
5996 arg1 = &temp1;
5997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5998 }
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 wxPoint *arg1 = 0 ;
6019 wxSize *arg2 = 0 ;
6020 wxRect *result = 0 ;
6021 wxPoint temp1 ;
6022 wxSize temp2 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "pos",(char *) "size", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6030 {
6031 arg1 = &temp1;
6032 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6033 }
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj = 0;
6053 wxSize *arg1 = 0 ;
6054 wxRect *result = 0 ;
6055 wxSize temp1 ;
6056 PyObject * obj0 = 0 ;
6057 char * kwnames[] = {
6058 (char *) "size", NULL
6059 };
6060
6061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6062 {
6063 arg1 = &temp1;
6064 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6065 }
6066 {
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6073 return resultobj;
6074 fail:
6075 return NULL;
6076 }
6077
6078
6079 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6080 PyObject *resultobj = 0;
6081 wxRect *arg1 = (wxRect *) 0 ;
6082 void *argp1 = 0 ;
6083 int res1 = 0 ;
6084 PyObject *swig_obj[1] ;
6085
6086 if (!args) SWIG_fail;
6087 swig_obj[0] = args;
6088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6089 if (!SWIG_IsOK(res1)) {
6090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6091 }
6092 arg1 = reinterpret_cast< wxRect * >(argp1);
6093 {
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 delete arg1;
6096
6097 wxPyEndAllowThreads(__tstate);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 resultobj = SWIG_Py_Void();
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6108 PyObject *resultobj = 0;
6109 wxRect *arg1 = (wxRect *) 0 ;
6110 int result;
6111 void *argp1 = 0 ;
6112 int res1 = 0 ;
6113 PyObject *swig_obj[1] ;
6114
6115 if (!args) SWIG_fail;
6116 swig_obj[0] = args;
6117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6118 if (!SWIG_IsOK(res1)) {
6119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6120 }
6121 arg1 = reinterpret_cast< wxRect * >(argp1);
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (int)((wxRect const *)arg1)->GetX();
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 resultobj = SWIG_From_int(static_cast< int >(result));
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj = 0;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 int arg2 ;
6139 void *argp1 = 0 ;
6140 int res1 = 0 ;
6141 int val2 ;
6142 int ecode2 = 0 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "self",(char *) "x", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6151 if (!SWIG_IsOK(res1)) {
6152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6153 }
6154 arg1 = reinterpret_cast< wxRect * >(argp1);
6155 ecode2 = SWIG_AsVal_int(obj1, &val2);
6156 if (!SWIG_IsOK(ecode2)) {
6157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6158 }
6159 arg2 = static_cast< int >(val2);
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 (arg1)->SetX(arg2);
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 resultobj = SWIG_Py_Void();
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 PyObject *resultobj = 0;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 int result;
6177 void *argp1 = 0 ;
6178 int res1 = 0 ;
6179 PyObject *swig_obj[1] ;
6180
6181 if (!args) SWIG_fail;
6182 swig_obj[0] = args;
6183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6186 }
6187 arg1 = reinterpret_cast< wxRect * >(argp1);
6188 {
6189 PyThreadState* __tstate = wxPyBeginAllowThreads();
6190 result = (int)(arg1)->GetY();
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_From_int(static_cast< int >(result));
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = 0;
6203 wxRect *arg1 = (wxRect *) 0 ;
6204 int arg2 ;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 int val2 ;
6208 int ecode2 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 char * kwnames[] = {
6212 (char *) "self",(char *) "y", NULL
6213 };
6214
6215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6219 }
6220 arg1 = reinterpret_cast< wxRect * >(argp1);
6221 ecode2 = SWIG_AsVal_int(obj1, &val2);
6222 if (!SWIG_IsOK(ecode2)) {
6223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6224 }
6225 arg2 = static_cast< int >(val2);
6226 {
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 (arg1)->SetY(arg2);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 resultobj = SWIG_Py_Void();
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240 PyObject *resultobj = 0;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 void *argp1 = 0 ;
6244 int res1 = 0 ;
6245 PyObject *swig_obj[1] ;
6246
6247 if (!args) SWIG_fail;
6248 swig_obj[0] = args;
6249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6250 if (!SWIG_IsOK(res1)) {
6251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6252 }
6253 arg1 = reinterpret_cast< wxRect * >(argp1);
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (int)((wxRect const *)arg1)->GetWidth();
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_From_int(static_cast< int >(result));
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 int val2 ;
6274 int ecode2 = 0 ;
6275 PyObject * obj0 = 0 ;
6276 PyObject * obj1 = 0 ;
6277 char * kwnames[] = {
6278 (char *) "self",(char *) "w", NULL
6279 };
6280
6281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6283 if (!SWIG_IsOK(res1)) {
6284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6285 }
6286 arg1 = reinterpret_cast< wxRect * >(argp1);
6287 ecode2 = SWIG_AsVal_int(obj1, &val2);
6288 if (!SWIG_IsOK(ecode2)) {
6289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6290 }
6291 arg2 = static_cast< int >(val2);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 (arg1)->SetWidth(arg2);
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_Py_Void();
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int result;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 PyObject *swig_obj[1] ;
6312
6313 if (!args) SWIG_fail;
6314 swig_obj[0] = args;
6315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6318 }
6319 arg1 = reinterpret_cast< wxRect * >(argp1);
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (int)((wxRect const *)arg1)->GetHeight();
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_From_int(static_cast< int >(result));
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj = 0;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int arg2 ;
6337 void *argp1 = 0 ;
6338 int res1 = 0 ;
6339 int val2 ;
6340 int ecode2 = 0 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char * kwnames[] = {
6344 (char *) "self",(char *) "h", NULL
6345 };
6346
6347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6349 if (!SWIG_IsOK(res1)) {
6350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6351 }
6352 arg1 = reinterpret_cast< wxRect * >(argp1);
6353 ecode2 = SWIG_AsVal_int(obj1, &val2);
6354 if (!SWIG_IsOK(ecode2)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6356 }
6357 arg2 = static_cast< int >(val2);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 (arg1)->SetHeight(arg2);
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_Py_Void();
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 wxPoint result;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 PyObject *swig_obj[1] ;
6378
6379 if (!args) SWIG_fail;
6380 swig_obj[0] = args;
6381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = ((wxRect const *)arg1)->GetPosition();
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 wxPoint *arg2 = 0 ;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 wxPoint temp2 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "p", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 {
6419 arg2 = &temp2;
6420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6421 }
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 (arg1)->SetPosition((wxPoint const &)*arg2);
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_Py_Void();
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 wxSize result;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = ((wxRect const *)arg1)->GetSize();
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj = 0;
6465 wxRect *arg1 = (wxRect *) 0 ;
6466 wxSize *arg2 = 0 ;
6467 void *argp1 = 0 ;
6468 int res1 = 0 ;
6469 wxSize temp2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char * kwnames[] = {
6473 (char *) "self",(char *) "s", NULL
6474 };
6475
6476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6478 if (!SWIG_IsOK(res1)) {
6479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6480 }
6481 arg1 = reinterpret_cast< wxRect * >(argp1);
6482 {
6483 arg2 = &temp2;
6484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 (arg1)->SetSize((wxSize const &)*arg2);
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_Py_Void();
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6500 PyObject *resultobj = 0;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 bool result;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 PyObject *swig_obj[1] ;
6506
6507 if (!args) SWIG_fail;
6508 swig_obj[0] = args;
6509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6510 if (!SWIG_IsOK(res1)) {
6511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6512 }
6513 arg1 = reinterpret_cast< wxRect * >(argp1);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (bool)((wxRect const *)arg1)->IsEmpty();
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 {
6521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6522 }
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 wxRect *arg1 = (wxRect *) 0 ;
6532 wxPoint result;
6533 void *argp1 = 0 ;
6534 int res1 = 0 ;
6535 PyObject *swig_obj[1] ;
6536
6537 if (!args) SWIG_fail;
6538 swig_obj[0] = args;
6539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6540 if (!SWIG_IsOK(res1)) {
6541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6542 }
6543 arg1 = reinterpret_cast< wxRect * >(argp1);
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = ((wxRect const *)arg1)->GetTopLeft();
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 wxPoint *arg2 = 0 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 wxPoint temp2 ;
6564 PyObject * obj0 = 0 ;
6565 PyObject * obj1 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "self",(char *) "p", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6572 if (!SWIG_IsOK(res1)) {
6573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6574 }
6575 arg1 = reinterpret_cast< wxRect * >(argp1);
6576 {
6577 arg2 = &temp2;
6578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6579 }
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 wxPoint result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = ((wxRect const *)arg1)->GetBottomRight();
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint *arg2 = 0 ;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 wxPoint temp2 ;
6628 PyObject * obj0 = 0 ;
6629 PyObject * obj1 = 0 ;
6630 char * kwnames[] = {
6631 (char *) "self",(char *) "p", NULL
6632 };
6633
6634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6636 if (!SWIG_IsOK(res1)) {
6637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6638 }
6639 arg1 = reinterpret_cast< wxRect * >(argp1);
6640 {
6641 arg2 = &temp2;
6642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_Py_Void();
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 int result;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 PyObject *swig_obj[1] ;
6664
6665 if (!args) SWIG_fail;
6666 swig_obj[0] = args;
6667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6668 if (!SWIG_IsOK(res1)) {
6669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6670 }
6671 arg1 = reinterpret_cast< wxRect * >(argp1);
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (int)((wxRect const *)arg1)->GetLeft();
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_From_int(static_cast< int >(result));
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 int result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (int)((wxRect const *)arg1)->GetTop();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_From_int(static_cast< int >(result));
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 int result;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 PyObject *swig_obj[1] ;
6720
6721 if (!args) SWIG_fail;
6722 swig_obj[0] = args;
6723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (int)((wxRect const *)arg1)->GetBottom();
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_From_int(static_cast< int >(result));
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 wxRect *arg1 = (wxRect *) 0 ;
6744 int result;
6745 void *argp1 = 0 ;
6746 int res1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 if (!args) SWIG_fail;
6750 swig_obj[0] = args;
6751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6752 if (!SWIG_IsOK(res1)) {
6753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6754 }
6755 arg1 = reinterpret_cast< wxRect * >(argp1);
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (int)((wxRect const *)arg1)->GetRight();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_From_int(static_cast< int >(result));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 int arg2 ;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 int val2 ;
6776 int ecode2 = 0 ;
6777 PyObject * obj0 = 0 ;
6778 PyObject * obj1 = 0 ;
6779 char * kwnames[] = {
6780 (char *) "self",(char *) "left", NULL
6781 };
6782
6783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6785 if (!SWIG_IsOK(res1)) {
6786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6787 }
6788 arg1 = reinterpret_cast< wxRect * >(argp1);
6789 ecode2 = SWIG_AsVal_int(obj1, &val2);
6790 if (!SWIG_IsOK(ecode2)) {
6791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6792 }
6793 arg2 = static_cast< int >(val2);
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 (arg1)->SetLeft(arg2);
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_Py_Void();
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int arg2 ;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 int val2 ;
6814 int ecode2 = 0 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "right", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 ecode2 = SWIG_AsVal_int(obj1, &val2);
6828 if (!SWIG_IsOK(ecode2)) {
6829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6830 }
6831 arg2 = static_cast< int >(val2);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 (arg1)->SetRight(arg2);
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_Py_Void();
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj = 0;
6847 wxRect *arg1 = (wxRect *) 0 ;
6848 int arg2 ;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 int val2 ;
6852 int ecode2 = 0 ;
6853 PyObject * obj0 = 0 ;
6854 PyObject * obj1 = 0 ;
6855 char * kwnames[] = {
6856 (char *) "self",(char *) "top", NULL
6857 };
6858
6859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6861 if (!SWIG_IsOK(res1)) {
6862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6863 }
6864 arg1 = reinterpret_cast< wxRect * >(argp1);
6865 ecode2 = SWIG_AsVal_int(obj1, &val2);
6866 if (!SWIG_IsOK(ecode2)) {
6867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6868 }
6869 arg2 = static_cast< int >(val2);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 (arg1)->SetTop(arg2);
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_Py_Void();
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int arg2 ;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 int val2 ;
6890 int ecode2 = 0 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char * kwnames[] = {
6894 (char *) "self",(char *) "bottom", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 ecode2 = SWIG_AsVal_int(obj1, &val2);
6904 if (!SWIG_IsOK(ecode2)) {
6905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6906 }
6907 arg2 = static_cast< int >(val2);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->SetBottom(arg2);
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_Py_Void();
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 int arg3 ;
6926 wxRect *result = 0 ;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 int val2 ;
6930 int ecode2 = 0 ;
6931 int val3 ;
6932 int ecode3 = 0 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 PyObject * obj2 = 0 ;
6936 char * kwnames[] = {
6937 (char *) "self",(char *) "dx",(char *) "dy", NULL
6938 };
6939
6940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6944 }
6945 arg1 = reinterpret_cast< wxRect * >(argp1);
6946 ecode2 = SWIG_AsVal_int(obj1, &val2);
6947 if (!SWIG_IsOK(ecode2)) {
6948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6949 }
6950 arg2 = static_cast< int >(val2);
6951 ecode3 = SWIG_AsVal_int(obj2, &val3);
6952 if (!SWIG_IsOK(ecode3)) {
6953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6954 }
6955 arg3 = static_cast< int >(val3);
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 {
6959 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6960 result = (wxRect *) &_result_ref;
6961 }
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 int arg2 ;
6976 int arg3 ;
6977 wxRect *result = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 int val2 ;
6981 int ecode2 = 0 ;
6982 int val3 ;
6983 int ecode3 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 PyObject * obj2 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "dx",(char *) "dy", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 ecode3 = SWIG_AsVal_int(obj2, &val3);
7003 if (!SWIG_IsOK(ecode3)) {
7004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7005 }
7006 arg3 = static_cast< int >(val3);
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 {
7010 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7011 result = (wxRect *) &_result_ref;
7012 }
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int arg2 ;
7027 int arg3 ;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 int val2 ;
7031 int ecode2 = 0 ;
7032 int val3 ;
7033 int ecode3 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 PyObject * obj2 = 0 ;
7037 char * kwnames[] = {
7038 (char *) "self",(char *) "dx",(char *) "dy", NULL
7039 };
7040
7041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7043 if (!SWIG_IsOK(res1)) {
7044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7045 }
7046 arg1 = reinterpret_cast< wxRect * >(argp1);
7047 ecode2 = SWIG_AsVal_int(obj1, &val2);
7048 if (!SWIG_IsOK(ecode2)) {
7049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7050 }
7051 arg2 = static_cast< int >(val2);
7052 ecode3 = SWIG_AsVal_int(obj2, &val3);
7053 if (!SWIG_IsOK(ecode3)) {
7054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7055 }
7056 arg3 = static_cast< int >(val3);
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 (arg1)->Offset(arg2,arg3);
7060 wxPyEndAllowThreads(__tstate);
7061 if (PyErr_Occurred()) SWIG_fail;
7062 }
7063 resultobj = SWIG_Py_Void();
7064 return resultobj;
7065 fail:
7066 return NULL;
7067 }
7068
7069
7070 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7071 PyObject *resultobj = 0;
7072 wxRect *arg1 = (wxRect *) 0 ;
7073 wxPoint *arg2 = 0 ;
7074 void *argp1 = 0 ;
7075 int res1 = 0 ;
7076 wxPoint temp2 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "pt", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7087 }
7088 arg1 = reinterpret_cast< wxRect * >(argp1);
7089 {
7090 arg2 = &temp2;
7091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7092 }
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 (arg1)->Offset((wxPoint const &)*arg2);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_Py_Void();
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj = 0;
7108 wxRect *arg1 = (wxRect *) 0 ;
7109 wxRect *arg2 = 0 ;
7110 wxRect result;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 wxRect temp2 ;
7114 PyObject * obj0 = 0 ;
7115 PyObject * obj1 = 0 ;
7116 char * kwnames[] = {
7117 (char *) "self",(char *) "rect", NULL
7118 };
7119
7120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7122 if (!SWIG_IsOK(res1)) {
7123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7124 }
7125 arg1 = reinterpret_cast< wxRect * >(argp1);
7126 {
7127 arg2 = &temp2;
7128 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7129 }
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (arg1)->Intersect((wxRect const &)*arg2);
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 wxRect *arg2 = 0 ;
7147 wxRect result;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 wxRect temp2 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "self",(char *) "rect", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7159 if (!SWIG_IsOK(res1)) {
7160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7161 }
7162 arg1 = reinterpret_cast< wxRect * >(argp1);
7163 {
7164 arg2 = &temp2;
7165 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 result = (arg1)->Union((wxRect const &)*arg2);
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj = 0;
7182 wxRect *arg1 = (wxRect *) 0 ;
7183 wxRect *arg2 = 0 ;
7184 wxRect result;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 wxRect temp2 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "self",(char *) "rect", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7196 if (!SWIG_IsOK(res1)) {
7197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7198 }
7199 arg1 = reinterpret_cast< wxRect * >(argp1);
7200 {
7201 arg2 = &temp2;
7202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7203 }
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj = 0;
7219 wxRect *arg1 = (wxRect *) 0 ;
7220 wxRect *arg2 = 0 ;
7221 wxRect *result = 0 ;
7222 void *argp1 = 0 ;
7223 int res1 = 0 ;
7224 wxRect temp2 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char * kwnames[] = {
7228 (char *) "self",(char *) "rect", NULL
7229 };
7230
7231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7233 if (!SWIG_IsOK(res1)) {
7234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7235 }
7236 arg1 = reinterpret_cast< wxRect * >(argp1);
7237 {
7238 arg2 = &temp2;
7239 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7240 }
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 {
7244 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7245 result = (wxRect *) &_result_ref;
7246 }
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 bool result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 {
7288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7289 }
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7297 PyObject *resultobj = 0;
7298 wxRect *arg1 = (wxRect *) 0 ;
7299 wxRect *arg2 = 0 ;
7300 bool result;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 wxRect temp2 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "self",(char *) "rect", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7314 }
7315 arg1 = reinterpret_cast< wxRect * >(argp1);
7316 {
7317 arg2 = &temp2;
7318 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7319 }
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 int arg2 ;
7339 int arg3 ;
7340 bool result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 int val2 ;
7344 int ecode2 = 0 ;
7345 int val3 ;
7346 int ecode3 = 0 ;
7347 PyObject * obj0 = 0 ;
7348 PyObject * obj1 = 0 ;
7349 PyObject * obj2 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "x",(char *) "y", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7358 }
7359 arg1 = reinterpret_cast< wxRect * >(argp1);
7360 ecode2 = SWIG_AsVal_int(obj1, &val2);
7361 if (!SWIG_IsOK(ecode2)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7363 }
7364 arg2 = static_cast< int >(val2);
7365 ecode3 = SWIG_AsVal_int(obj2, &val3);
7366 if (!SWIG_IsOK(ecode3)) {
7367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7368 }
7369 arg3 = static_cast< int >(val3);
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 {
7377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7378 }
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj = 0;
7387 wxRect *arg1 = (wxRect *) 0 ;
7388 wxPoint *arg2 = 0 ;
7389 bool result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 wxPoint temp2 ;
7393 PyObject * obj0 = 0 ;
7394 PyObject * obj1 = 0 ;
7395 char * kwnames[] = {
7396 (char *) "self",(char *) "pt", NULL
7397 };
7398
7399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7401 if (!SWIG_IsOK(res1)) {
7402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7403 }
7404 arg1 = reinterpret_cast< wxRect * >(argp1);
7405 {
7406 arg2 = &temp2;
7407 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7408 }
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj = 0;
7426 wxRect *arg1 = (wxRect *) 0 ;
7427 wxRect *arg2 = 0 ;
7428 bool result;
7429 void *argp1 = 0 ;
7430 int res1 = 0 ;
7431 wxRect temp2 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char * kwnames[] = {
7435 (char *) "self",(char *) "rect", NULL
7436 };
7437
7438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7440 if (!SWIG_IsOK(res1)) {
7441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7442 }
7443 arg1 = reinterpret_cast< wxRect * >(argp1);
7444 {
7445 arg2 = &temp2;
7446 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxRect *arg2 = 0 ;
7467 int arg3 = (int) wxBOTH ;
7468 wxRect result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxRect temp2 ;
7472 int val3 ;
7473 int ecode3 = 0 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 PyObject * obj2 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "r",(char *) "dir", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 {
7488 arg2 = &temp2;
7489 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7490 }
7491 if (obj2) {
7492 ecode3 = SWIG_AsVal_int(obj2, &val3);
7493 if (!SWIG_IsOK(ecode3)) {
7494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7495 }
7496 arg3 = static_cast< int >(val3);
7497 }
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7512 PyObject *resultobj = 0;
7513 wxRect *arg1 = (wxRect *) 0 ;
7514 int arg2 ;
7515 void *argp1 = 0 ;
7516 int res1 = 0 ;
7517 int val2 ;
7518 int ecode2 = 0 ;
7519 PyObject *swig_obj[2] ;
7520
7521 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7525 }
7526 arg1 = reinterpret_cast< wxRect * >(argp1);
7527 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7528 if (!SWIG_IsOK(ecode2)) {
7529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7530 }
7531 arg2 = static_cast< int >(val2);
7532 if (arg1) (arg1)->x = arg2;
7533
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7542 PyObject *resultobj = 0;
7543 wxRect *arg1 = (wxRect *) 0 ;
7544 int result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 PyObject *swig_obj[1] ;
7548
7549 if (!args) SWIG_fail;
7550 swig_obj[0] = args;
7551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7554 }
7555 arg1 = reinterpret_cast< wxRect * >(argp1);
7556 result = (int) ((arg1)->x);
7557 resultobj = SWIG_From_int(static_cast< int >(result));
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7565 PyObject *resultobj = 0;
7566 wxRect *arg1 = (wxRect *) 0 ;
7567 int arg2 ;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 int val2 ;
7571 int ecode2 = 0 ;
7572 PyObject *swig_obj[2] ;
7573
7574 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7578 }
7579 arg1 = reinterpret_cast< wxRect * >(argp1);
7580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7581 if (!SWIG_IsOK(ecode2)) {
7582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7583 }
7584 arg2 = static_cast< int >(val2);
7585 if (arg1) (arg1)->y = arg2;
7586
7587 resultobj = SWIG_Py_Void();
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7595 PyObject *resultobj = 0;
7596 wxRect *arg1 = (wxRect *) 0 ;
7597 int result;
7598 void *argp1 = 0 ;
7599 int res1 = 0 ;
7600 PyObject *swig_obj[1] ;
7601
7602 if (!args) SWIG_fail;
7603 swig_obj[0] = args;
7604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 result = (int) ((arg1)->y);
7610 resultobj = SWIG_From_int(static_cast< int >(result));
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *resultobj = 0;
7619 wxRect *arg1 = (wxRect *) 0 ;
7620 int arg2 ;
7621 void *argp1 = 0 ;
7622 int res1 = 0 ;
7623 int val2 ;
7624 int ecode2 = 0 ;
7625 PyObject *swig_obj[2] ;
7626
7627 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7629 if (!SWIG_IsOK(res1)) {
7630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7631 }
7632 arg1 = reinterpret_cast< wxRect * >(argp1);
7633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7634 if (!SWIG_IsOK(ecode2)) {
7635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7636 }
7637 arg2 = static_cast< int >(val2);
7638 if (arg1) (arg1)->width = arg2;
7639
7640 resultobj = SWIG_Py_Void();
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 int result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 PyObject *swig_obj[1] ;
7654
7655 if (!args) SWIG_fail;
7656 swig_obj[0] = args;
7657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 result = (int) ((arg1)->width);
7663 resultobj = SWIG_From_int(static_cast< int >(result));
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject *swig_obj[2] ;
7679
7680 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7684 }
7685 arg1 = reinterpret_cast< wxRect * >(argp1);
7686 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 if (arg1) (arg1)->height = arg2;
7692
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7701 PyObject *resultobj = 0;
7702 wxRect *arg1 = (wxRect *) 0 ;
7703 int result;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 PyObject *swig_obj[1] ;
7707
7708 if (!args) SWIG_fail;
7709 swig_obj[0] = args;
7710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 result = (int) ((arg1)->height);
7716 resultobj = SWIG_From_int(static_cast< int >(result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int arg2 = (int) 0 ;
7727 int arg3 = (int) 0 ;
7728 int arg4 = (int) 0 ;
7729 int arg5 = (int) 0 ;
7730 void *argp1 = 0 ;
7731 int res1 = 0 ;
7732 int val2 ;
7733 int ecode2 = 0 ;
7734 int val3 ;
7735 int ecode3 = 0 ;
7736 int val4 ;
7737 int ecode4 = 0 ;
7738 int val5 ;
7739 int ecode5 = 0 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 PyObject * obj2 = 0 ;
7743 PyObject * obj3 = 0 ;
7744 PyObject * obj4 = 0 ;
7745 char * kwnames[] = {
7746 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7747 };
7748
7749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7753 }
7754 arg1 = reinterpret_cast< wxRect * >(argp1);
7755 if (obj1) {
7756 ecode2 = SWIG_AsVal_int(obj1, &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7759 }
7760 arg2 = static_cast< int >(val2);
7761 }
7762 if (obj2) {
7763 ecode3 = SWIG_AsVal_int(obj2, &val3);
7764 if (!SWIG_IsOK(ecode3)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7766 }
7767 arg3 = static_cast< int >(val3);
7768 }
7769 if (obj3) {
7770 ecode4 = SWIG_AsVal_int(obj3, &val4);
7771 if (!SWIG_IsOK(ecode4)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7773 }
7774 arg4 = static_cast< int >(val4);
7775 }
7776 if (obj4) {
7777 ecode5 = SWIG_AsVal_int(obj4, &val5);
7778 if (!SWIG_IsOK(ecode5)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7780 }
7781 arg5 = static_cast< int >(val5);
7782 }
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 PyObject *resultobj = 0;
7798 wxRect *arg1 = (wxRect *) 0 ;
7799 PyObject *result = 0 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 PyObject *swig_obj[1] ;
7803
7804 if (!args) SWIG_fail;
7805 swig_obj[0] = args;
7806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (PyObject *)wxRect_Get(arg1);
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = result;
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *obj;
7826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7827 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7828 return SWIG_Py_Void();
7829 }
7830
7831 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832 return SWIG_Python_InitShadowInstance(args);
7833 }
7834
7835 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxRect *arg1 = (wxRect *) 0 ;
7838 wxRect *arg2 = (wxRect *) 0 ;
7839 PyObject *result = 0 ;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 void *argp2 = 0 ;
7843 int res2 = 0 ;
7844 PyObject * obj0 = 0 ;
7845 PyObject * obj1 = 0 ;
7846 char * kwnames[] = {
7847 (char *) "r1",(char *) "r2", NULL
7848 };
7849
7850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7852 if (!SWIG_IsOK(res1)) {
7853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7854 }
7855 arg1 = reinterpret_cast< wxRect * >(argp1);
7856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7857 if (!SWIG_IsOK(res2)) {
7858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7859 }
7860 arg2 = reinterpret_cast< wxRect * >(argp2);
7861 {
7862 if (!wxPyCheckForApp()) SWIG_fail;
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (PyObject *)wxIntersectRect(arg1,arg2);
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 resultobj = result;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj = 0;
7877 double arg1 = (double) 0.0 ;
7878 double arg2 = (double) 0.0 ;
7879 wxPoint2D *result = 0 ;
7880 double val1 ;
7881 int ecode1 = 0 ;
7882 double val2 ;
7883 int ecode2 = 0 ;
7884 PyObject * obj0 = 0 ;
7885 PyObject * obj1 = 0 ;
7886 char * kwnames[] = {
7887 (char *) "x",(char *) "y", NULL
7888 };
7889
7890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7891 if (obj0) {
7892 ecode1 = SWIG_AsVal_double(obj0, &val1);
7893 if (!SWIG_IsOK(ecode1)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7895 }
7896 arg1 = static_cast< double >(val1);
7897 }
7898 if (obj1) {
7899 ecode2 = SWIG_AsVal_double(obj1, &val2);
7900 if (!SWIG_IsOK(ecode2)) {
7901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7902 }
7903 arg2 = static_cast< double >(val2);
7904 }
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7919 PyObject *resultobj = 0;
7920 wxPoint2D *arg1 = 0 ;
7921 wxPoint2D *result = 0 ;
7922 wxPoint2D temp1 ;
7923 PyObject * obj0 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "pt", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7929 {
7930 arg1 = &temp1;
7931 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7932 }
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7947 PyObject *resultobj = 0;
7948 wxPoint *arg1 = 0 ;
7949 wxPoint2D *result = 0 ;
7950 wxPoint temp1 ;
7951 PyObject * obj0 = 0 ;
7952 char * kwnames[] = {
7953 (char *) "pt", NULL
7954 };
7955
7956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7957 {
7958 arg1 = &temp1;
7959 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7960 }
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 PyObject *resultobj = 0;
7976 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7977 int *arg2 = (int *) 0 ;
7978 int *arg3 = (int *) 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 int temp2 ;
7982 int res2 = SWIG_TMPOBJ ;
7983 int temp3 ;
7984 int res3 = SWIG_TMPOBJ ;
7985 PyObject *swig_obj[1] ;
7986
7987 arg2 = &temp2;
7988 arg3 = &temp3;
7989 if (!args) SWIG_fail;
7990 swig_obj[0] = args;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7994 }
7995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 if (SWIG_IsTmpObj(res2)) {
8004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8005 } else {
8006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8008 }
8009 if (SWIG_IsTmpObj(res3)) {
8010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8011 } else {
8012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8014 }
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8024 int *arg2 = (int *) 0 ;
8025 int *arg3 = (int *) 0 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int temp2 ;
8029 int res2 = SWIG_TMPOBJ ;
8030 int temp3 ;
8031 int res3 = SWIG_TMPOBJ ;
8032 PyObject *swig_obj[1] ;
8033
8034 arg2 = &temp2;
8035 arg3 = &temp3;
8036 if (!args) SWIG_fail;
8037 swig_obj[0] = args;
8038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8039 if (!SWIG_IsOK(res1)) {
8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8041 }
8042 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_Py_Void();
8050 if (SWIG_IsTmpObj(res2)) {
8051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8052 } else {
8053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8055 }
8056 if (SWIG_IsTmpObj(res3)) {
8057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8058 } else {
8059 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8061 }
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8071 double result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 resultobj = SWIG_From_double(static_cast< double >(result));
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8097 PyObject *resultobj = 0;
8098 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8099 double result;
8100 void *argp1 = 0 ;
8101 int res1 = 0 ;
8102 PyObject *swig_obj[1] ;
8103
8104 if (!args) SWIG_fail;
8105 swig_obj[0] = args;
8106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8107 if (!SWIG_IsOK(res1)) {
8108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8109 }
8110 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 resultobj = SWIG_From_double(static_cast< double >(result));
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj = 0;
8126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8127 double arg2 ;
8128 void *argp1 = 0 ;
8129 int res1 = 0 ;
8130 double val2 ;
8131 int ecode2 = 0 ;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "self",(char *) "length", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8140 if (!SWIG_IsOK(res1)) {
8141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8142 }
8143 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8144 ecode2 = SWIG_AsVal_double(obj1, &val2);
8145 if (!SWIG_IsOK(ecode2)) {
8146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8147 }
8148 arg2 = static_cast< double >(val2);
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 (arg1)->SetVectorLength(arg2);
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 resultobj = SWIG_Py_Void();
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj = 0;
8164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8165 double arg2 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 double val2 ;
8169 int ecode2 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char * kwnames[] = {
8173 (char *) "self",(char *) "degrees", NULL
8174 };
8175
8176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 ecode2 = SWIG_AsVal_double(obj1, &val2);
8183 if (!SWIG_IsOK(ecode2)) {
8184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8185 }
8186 arg2 = static_cast< double >(val2);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 (arg1)->SetVectorAngle(arg2);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_Py_Void();
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8203 wxPoint2D *arg2 = 0 ;
8204 double result;
8205 void *argp1 = 0 ;
8206 int res1 = 0 ;
8207 wxPoint2D temp2 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "pt", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8218 }
8219 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8220 {
8221 arg2 = &temp2;
8222 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8223 }
8224 {
8225 PyThreadState* __tstate = wxPyBeginAllowThreads();
8226 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8227 wxPyEndAllowThreads(__tstate);
8228 if (PyErr_Occurred()) SWIG_fail;
8229 }
8230 resultobj = SWIG_From_double(static_cast< double >(result));
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = 0;
8239 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8240 wxPoint2D *arg2 = 0 ;
8241 double result;
8242 void *argp1 = 0 ;
8243 int res1 = 0 ;
8244 wxPoint2D temp2 ;
8245 PyObject * obj0 = 0 ;
8246 PyObject * obj1 = 0 ;
8247 char * kwnames[] = {
8248 (char *) "self",(char *) "pt", NULL
8249 };
8250
8251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8253 if (!SWIG_IsOK(res1)) {
8254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8255 }
8256 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8257 {
8258 arg2 = &temp2;
8259 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8260 }
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_From_double(static_cast< double >(result));
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8277 wxPoint2D *arg2 = 0 ;
8278 double result;
8279 void *argp1 = 0 ;
8280 int res1 = 0 ;
8281 wxPoint2D temp2 ;
8282 PyObject * obj0 = 0 ;
8283 PyObject * obj1 = 0 ;
8284 char * kwnames[] = {
8285 (char *) "self",(char *) "vec", NULL
8286 };
8287
8288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8292 }
8293 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8294 {
8295 arg2 = &temp2;
8296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8297 }
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_From_double(static_cast< double >(result));
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj = 0;
8313 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8314 wxPoint2D *arg2 = 0 ;
8315 double result;
8316 void *argp1 = 0 ;
8317 int res1 = 0 ;
8318 wxPoint2D temp2 ;
8319 PyObject * obj0 = 0 ;
8320 PyObject * obj1 = 0 ;
8321 char * kwnames[] = {
8322 (char *) "self",(char *) "vec", NULL
8323 };
8324
8325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8327 if (!SWIG_IsOK(res1)) {
8328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8329 }
8330 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8331 {
8332 arg2 = &temp2;
8333 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 resultobj = SWIG_From_double(static_cast< double >(result));
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8349 PyObject *resultobj = 0;
8350 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8351 wxPoint2D result;
8352 void *argp1 = 0 ;
8353 int res1 = 0 ;
8354 PyObject *swig_obj[1] ;
8355
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (arg1)->operator -();
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 wxPoint2D *result = 0 ;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 {
8403 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8404 result = (wxPoint2D *) &_result_ref;
8405 }
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 wxPoint2D *arg2 = 0 ;
8420 wxPoint2D *result = 0 ;
8421 void *argp1 = 0 ;
8422 int res1 = 0 ;
8423 wxPoint2D temp2 ;
8424 PyObject * obj0 = 0 ;
8425 PyObject * obj1 = 0 ;
8426 char * kwnames[] = {
8427 (char *) "self",(char *) "pt", NULL
8428 };
8429
8430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8432 if (!SWIG_IsOK(res1)) {
8433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8434 }
8435 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8436 {
8437 arg2 = &temp2;
8438 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8439 }
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 {
8443 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8444 result = (wxPoint2D *) &_result_ref;
8445 }
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 wxPoint2D *result = 0 ;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "pt", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 {
8483 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8484 result = (wxPoint2D *) &_result_ref;
8485 }
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj = 0;
8498 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8499 wxPoint2D *arg2 = 0 ;
8500 wxPoint2D *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 wxPoint2D temp2 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "pt", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8514 }
8515 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8516 {
8517 arg2 = &temp2;
8518 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 {
8523 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8524 result = (wxPoint2D *) &_result_ref;
8525 }
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 bool result;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 {
8567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568 }
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 bool result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8607 }
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 double arg2 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 double val2 ;
8621 int ecode2 = 0 ;
8622 PyObject *swig_obj[2] ;
8623
8624 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8631 if (!SWIG_IsOK(ecode2)) {
8632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8633 }
8634 arg2 = static_cast< double >(val2);
8635 if (arg1) (arg1)->m_x = arg2;
8636
8637 resultobj = SWIG_Py_Void();
8638 return resultobj;
8639 fail:
8640 return NULL;
8641 }
8642
8643
8644 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8645 PyObject *resultobj = 0;
8646 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8647 double result;
8648 void *argp1 = 0 ;
8649 int res1 = 0 ;
8650 PyObject *swig_obj[1] ;
8651
8652 if (!args) SWIG_fail;
8653 swig_obj[0] = args;
8654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8657 }
8658 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8659 result = (double) ((arg1)->m_x);
8660 resultobj = SWIG_From_double(static_cast< double >(result));
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8668 PyObject *resultobj = 0;
8669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8670 double arg2 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 double val2 ;
8674 int ecode2 = 0 ;
8675 PyObject *swig_obj[2] ;
8676
8677 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8679 if (!SWIG_IsOK(res1)) {
8680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8681 }
8682 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8683 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8684 if (!SWIG_IsOK(ecode2)) {
8685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8686 }
8687 arg2 = static_cast< double >(val2);
8688 if (arg1) (arg1)->m_y = arg2;
8689
8690 resultobj = SWIG_Py_Void();
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 PyObject *swig_obj[1] ;
8704
8705 if (!args) SWIG_fail;
8706 swig_obj[0] = args;
8707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 result = (double) ((arg1)->m_y);
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double arg2 = (double) 0 ;
8724 double arg3 = (double) 0 ;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 double val2 ;
8728 int ecode2 = 0 ;
8729 double val3 ;
8730 int ecode3 = 0 ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 PyObject * obj2 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "x",(char *) "y", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 if (obj1) {
8745 ecode2 = SWIG_AsVal_double(obj1, &val2);
8746 if (!SWIG_IsOK(ecode2)) {
8747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8748 }
8749 arg2 = static_cast< double >(val2);
8750 }
8751 if (obj2) {
8752 ecode3 = SWIG_AsVal_double(obj2, &val3);
8753 if (!SWIG_IsOK(ecode3)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8755 }
8756 arg3 = static_cast< double >(val3);
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 wxPoint2D_Set(arg1,arg2,arg3);
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 PyObject *result = 0 ;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 result = (PyObject *)wxPoint2D_Get(arg1);
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 resultobj = result;
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *obj;
8801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8802 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8803 return SWIG_Py_Void();
8804 }
8805
8806 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8807 return SWIG_Python_InitShadowInstance(args);
8808 }
8809
8810 SWIGINTERN int DefaultPosition_set(PyObject *) {
8811 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8812 return 1;
8813 }
8814
8815
8816 SWIGINTERN PyObject *DefaultPosition_get(void) {
8817 PyObject *pyobj = 0;
8818
8819 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8820 return pyobj;
8821 }
8822
8823
8824 SWIGINTERN int DefaultSize_set(PyObject *) {
8825 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8826 return 1;
8827 }
8828
8829
8830 SWIGINTERN PyObject *DefaultSize_get(void) {
8831 PyObject *pyobj = 0;
8832
8833 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8834 return pyobj;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 PyObject *arg1 = (PyObject *) 0 ;
8841 wxPyInputStream *result = 0 ;
8842 PyObject * obj0 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "p", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8848 arg1 = obj0;
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8863 PyObject *resultobj = 0;
8864 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8865 void *argp1 = 0 ;
8866 int res1 = 0 ;
8867 PyObject *swig_obj[1] ;
8868
8869 if (!args) SWIG_fail;
8870 swig_obj[0] = args;
8871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8872 if (!SWIG_IsOK(res1)) {
8873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8874 }
8875 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8876 {
8877 PyThreadState* __tstate = wxPyBeginAllowThreads();
8878 delete arg1;
8879
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_Py_Void();
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891 PyObject *resultobj = 0;
8892 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8893 void *argp1 = 0 ;
8894 int res1 = 0 ;
8895 PyObject *swig_obj[1] ;
8896
8897 if (!args) SWIG_fail;
8898 swig_obj[0] = args;
8899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8900 if (!SWIG_IsOK(res1)) {
8901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8902 }
8903 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 (arg1)->close();
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 resultobj = SWIG_Py_Void();
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918 PyObject *resultobj = 0;
8919 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 PyObject *swig_obj[1] ;
8923
8924 if (!args) SWIG_fail;
8925 swig_obj[0] = args;
8926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8927 if (!SWIG_IsOK(res1)) {
8928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8929 }
8930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 (arg1)->flush();
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *resultobj = 0;
8946 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8947 bool result;
8948 void *argp1 = 0 ;
8949 int res1 = 0 ;
8950 PyObject *swig_obj[1] ;
8951
8952 if (!args) SWIG_fail;
8953 swig_obj[0] = args;
8954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8955 if (!SWIG_IsOK(res1)) {
8956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8957 }
8958 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8959 {
8960 PyThreadState* __tstate = wxPyBeginAllowThreads();
8961 result = (bool)(arg1)->eof();
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 {
8966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj = 0;
8976 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8977 int arg2 = (int) -1 ;
8978 PyObject *result = 0 ;
8979 void *argp1 = 0 ;
8980 int res1 = 0 ;
8981 int val2 ;
8982 int ecode2 = 0 ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 char * kwnames[] = {
8986 (char *) "self",(char *) "size", NULL
8987 };
8988
8989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8991 if (!SWIG_IsOK(res1)) {
8992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8993 }
8994 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8995 if (obj1) {
8996 ecode2 = SWIG_AsVal_int(obj1, &val2);
8997 if (!SWIG_IsOK(ecode2)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
8999 }
9000 arg2 = static_cast< int >(val2);
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 result = (PyObject *)(arg1)->read(arg2);
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 resultobj = result;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj = 0;
9017 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9018 int arg2 = (int) -1 ;
9019 PyObject *result = 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 int val2 ;
9023 int ecode2 = 0 ;
9024 PyObject * obj0 = 0 ;
9025 PyObject * obj1 = 0 ;
9026 char * kwnames[] = {
9027 (char *) "self",(char *) "size", NULL
9028 };
9029
9030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9034 }
9035 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9036 if (obj1) {
9037 ecode2 = SWIG_AsVal_int(obj1, &val2);
9038 if (!SWIG_IsOK(ecode2)) {
9039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9040 }
9041 arg2 = static_cast< int >(val2);
9042 }
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 result = (PyObject *)(arg1)->readline(arg2);
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = result;
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj = 0;
9058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9059 int arg2 = (int) -1 ;
9060 PyObject *result = 0 ;
9061 void *argp1 = 0 ;
9062 int res1 = 0 ;
9063 int val2 ;
9064 int ecode2 = 0 ;
9065 PyObject * obj0 = 0 ;
9066 PyObject * obj1 = 0 ;
9067 char * kwnames[] = {
9068 (char *) "self",(char *) "sizehint", NULL
9069 };
9070
9071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9073 if (!SWIG_IsOK(res1)) {
9074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9075 }
9076 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9077 if (obj1) {
9078 ecode2 = SWIG_AsVal_int(obj1, &val2);
9079 if (!SWIG_IsOK(ecode2)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9081 }
9082 arg2 = static_cast< int >(val2);
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 result = (PyObject *)(arg1)->readlines(arg2);
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = result;
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj = 0;
9099 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9100 int arg2 ;
9101 int arg3 = (int) 0 ;
9102 void *argp1 = 0 ;
9103 int res1 = 0 ;
9104 int val2 ;
9105 int ecode2 = 0 ;
9106 int val3 ;
9107 int ecode3 = 0 ;
9108 PyObject * obj0 = 0 ;
9109 PyObject * obj1 = 0 ;
9110 PyObject * obj2 = 0 ;
9111 char * kwnames[] = {
9112 (char *) "self",(char *) "offset",(char *) "whence", NULL
9113 };
9114
9115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9121 ecode2 = SWIG_AsVal_int(obj1, &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9124 }
9125 arg2 = static_cast< int >(val2);
9126 if (obj2) {
9127 ecode3 = SWIG_AsVal_int(obj2, &val3);
9128 if (!SWIG_IsOK(ecode3)) {
9129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9130 }
9131 arg3 = static_cast< int >(val3);
9132 }
9133 {
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 (arg1)->seek(arg2,arg3);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_Py_Void();
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9149 int result;
9150 void *argp1 = 0 ;
9151 int res1 = 0 ;
9152 PyObject *swig_obj[1] ;
9153
9154 if (!args) SWIG_fail;
9155 swig_obj[0] = args;
9156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9159 }
9160 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (int)(arg1)->tell();
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_From_int(static_cast< int >(result));
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *resultobj = 0;
9176 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9177 char result;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 PyObject *swig_obj[1] ;
9181
9182 if (!args) SWIG_fail;
9183 swig_obj[0] = args;
9184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (char)(arg1)->Peek();
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 resultobj = SWIG_From_char(static_cast< char >(result));
9196 return resultobj;
9197 fail:
9198 return NULL;
9199 }
9200
9201
9202 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9203 PyObject *resultobj = 0;
9204 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9205 char result;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 PyObject *swig_obj[1] ;
9209
9210 if (!args) SWIG_fail;
9211 swig_obj[0] = args;
9212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9213 if (!SWIG_IsOK(res1)) {
9214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9215 }
9216 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (char)(arg1)->GetC();
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_From_char(static_cast< char >(result));
9224 return resultobj;
9225 fail:
9226 return NULL;
9227 }
9228
9229
9230 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231 PyObject *resultobj = 0;
9232 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9233 size_t result;
9234 void *argp1 = 0 ;
9235 int res1 = 0 ;
9236 PyObject *swig_obj[1] ;
9237
9238 if (!args) SWIG_fail;
9239 swig_obj[0] = args;
9240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9241 if (!SWIG_IsOK(res1)) {
9242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9243 }
9244 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (size_t)(arg1)->LastRead();
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 bool result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (bool)(arg1)->CanRead();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9281 }
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9289 PyObject *resultobj = 0;
9290 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9291 bool result;
9292 void *argp1 = 0 ;
9293 int res1 = 0 ;
9294 PyObject *swig_obj[1] ;
9295
9296 if (!args) SWIG_fail;
9297 swig_obj[0] = args;
9298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9301 }
9302 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 result = (bool)(arg1)->Eof();
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 {
9310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9311 }
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9319 PyObject *resultobj = 0;
9320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9321 char arg2 ;
9322 bool result;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 char val2 ;
9326 int ecode2 = 0 ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 char * kwnames[] = {
9330 (char *) "self",(char *) "c", NULL
9331 };
9332
9333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 ecode2 = SWIG_AsVal_char(obj1, &val2);
9340 if (!SWIG_IsOK(ecode2)) {
9341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9342 }
9343 arg2 = static_cast< char >(val2);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (bool)(arg1)->Ungetch(arg2);
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 {
9351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9352 }
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 long arg2 ;
9363 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9364 long result;
9365 void *argp1 = 0 ;
9366 int res1 = 0 ;
9367 long val2 ;
9368 int ecode2 = 0 ;
9369 int val3 ;
9370 int ecode3 = 0 ;
9371 PyObject * obj0 = 0 ;
9372 PyObject * obj1 = 0 ;
9373 PyObject * obj2 = 0 ;
9374 char * kwnames[] = {
9375 (char *) "self",(char *) "pos",(char *) "mode", NULL
9376 };
9377
9378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9382 }
9383 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9384 ecode2 = SWIG_AsVal_long(obj1, &val2);
9385 if (!SWIG_IsOK(ecode2)) {
9386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9387 }
9388 arg2 = static_cast< long >(val2);
9389 if (obj2) {
9390 ecode3 = SWIG_AsVal_int(obj2, &val3);
9391 if (!SWIG_IsOK(ecode3)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9393 }
9394 arg3 = static_cast< wxSeekMode >(val3);
9395 }
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (long)(arg1)->SeekI(arg2,arg3);
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_From_long(static_cast< long >(result));
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410 PyObject *resultobj = 0;
9411 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9412 long result;
9413 void *argp1 = 0 ;
9414 int res1 = 0 ;
9415 PyObject *swig_obj[1] ;
9416
9417 if (!args) SWIG_fail;
9418 swig_obj[0] = args;
9419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9422 }
9423 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (long)(arg1)->TellI();
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = SWIG_From_long(static_cast< long >(result));
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9438 PyObject *obj;
9439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9441 return SWIG_Py_Void();
9442 }
9443
9444 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 return SWIG_Python_InitShadowInstance(args);
9446 }
9447
9448 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj = 0;
9450 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9451 PyObject *arg2 = (PyObject *) 0 ;
9452 void *argp1 = 0 ;
9453 int res1 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "obj", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9466 arg2 = obj1;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 wxOutputStream_write(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9483 size_t result;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9493 }
9494 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 PyObject *obj;
9510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9511 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9512 return SWIG_Py_Void();
9513 }
9514
9515 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxInputStream *arg1 = (wxInputStream *) 0 ;
9518 wxString *arg2 = 0 ;
9519 wxString *arg3 = 0 ;
9520 wxString *arg4 = 0 ;
9521 wxDateTime arg5 ;
9522 wxFSFile *result = 0 ;
9523 wxPyInputStream *temp1 ;
9524 bool temp2 = false ;
9525 bool temp3 = false ;
9526 bool temp4 = false ;
9527 void *argp5 ;
9528 int res5 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 PyObject * obj2 = 0 ;
9532 PyObject * obj3 = 0 ;
9533 PyObject * obj4 = 0 ;
9534 char * kwnames[] = {
9535 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9536 };
9537
9538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9539 {
9540 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9541 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9542 } else {
9543 PyErr_Clear(); // clear the failure of the wxPyConvert above
9544 arg1 = wxPyCBInputStream_create(obj0, true);
9545 if (arg1 == NULL) {
9546 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9547 SWIG_fail;
9548 }
9549 }
9550 }
9551 {
9552 arg2 = wxString_in_helper(obj1);
9553 if (arg2 == NULL) SWIG_fail;
9554 temp2 = true;
9555 }
9556 {
9557 arg3 = wxString_in_helper(obj2);
9558 if (arg3 == NULL) SWIG_fail;
9559 temp3 = true;
9560 }
9561 {
9562 arg4 = wxString_in_helper(obj3);
9563 if (arg4 == NULL) SWIG_fail;
9564 temp4 = true;
9565 }
9566 {
9567 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9568 if (!SWIG_IsOK(res5)) {
9569 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9570 }
9571 if (!argp5) {
9572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9573 } else {
9574 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9575 arg5 = *temp;
9576 if (SWIG_IsNewObj(res5)) delete temp;
9577 }
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9587 }
9588 {
9589 if (temp2)
9590 delete arg2;
9591 }
9592 {
9593 if (temp3)
9594 delete arg3;
9595 }
9596 {
9597 if (temp4)
9598 delete arg4;
9599 }
9600 return resultobj;
9601 fail:
9602 {
9603 if (temp2)
9604 delete arg2;
9605 }
9606 {
9607 if (temp3)
9608 delete arg3;
9609 }
9610 {
9611 if (temp4)
9612 delete arg4;
9613 }
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxFSFile *arg1 = (wxFSFile *) 0 ;
9621 void *argp1 = 0 ;
9622 int res1 = 0 ;
9623 PyObject *swig_obj[1] ;
9624
9625 if (!args) SWIG_fail;
9626 swig_obj[0] = args;
9627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9628 if (!SWIG_IsOK(res1)) {
9629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9630 }
9631 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 delete arg1;
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxFSFile *arg1 = (wxFSFile *) 0 ;
9649 wxInputStream *result = 0 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9659 }
9660 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (wxInputStream *)(arg1)->GetStream();
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 {
9668 wxPyInputStream * _ptr = NULL;
9669
9670 if (result) {
9671 _ptr = new wxPyInputStream(result);
9672 }
9673 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9674 }
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 PyObject *resultobj = 0;
9683 wxFSFile *arg1 = (wxFSFile *) 0 ;
9684 wxString *result = 0 ;
9685 void *argp1 = 0 ;
9686 int res1 = 0 ;
9687 PyObject *swig_obj[1] ;
9688
9689 if (!args) SWIG_fail;
9690 swig_obj[0] = args;
9691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9694 }
9695 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9696 {
9697 PyThreadState* __tstate = wxPyBeginAllowThreads();
9698 {
9699 wxString const &_result_ref = (arg1)->GetMimeType();
9700 result = (wxString *) &_result_ref;
9701 }
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 #if wxUSE_UNICODE
9707 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9708 #else
9709 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9710 #endif
9711 }
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxFSFile *arg1 = (wxFSFile *) 0 ;
9721 wxString *result = 0 ;
9722 void *argp1 = 0 ;
9723 int res1 = 0 ;
9724 PyObject *swig_obj[1] ;
9725
9726 if (!args) SWIG_fail;
9727 swig_obj[0] = args;
9728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9731 }
9732 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 {
9736 wxString const &_result_ref = (arg1)->GetLocation();
9737 result = (wxString *) &_result_ref;
9738 }
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 {
9743 #if wxUSE_UNICODE
9744 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9745 #else
9746 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9747 #endif
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxString *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 {
9773 wxString const &_result_ref = (arg1)->GetAnchor();
9774 result = (wxString *) &_result_ref;
9775 }
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 {
9780 #if wxUSE_UNICODE
9781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9782 #else
9783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9784 #endif
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFSFile *arg1 = (wxFSFile *) 0 ;
9795 wxDateTime result;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = (arg1)->GetModificationTime();
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9821 PyObject *obj;
9822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9823 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9824 return SWIG_Py_Void();
9825 }
9826
9827 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9828 return SWIG_Python_InitShadowInstance(args);
9829 }
9830
9831 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *obj;
9833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9834 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9835 return SWIG_Py_Void();
9836 }
9837
9838 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9839 PyObject *resultobj = 0;
9840 wxPyFileSystemHandler *result = 0 ;
9841
9842 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
9856 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj = 0;
9858 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9859 PyObject *arg2 = (PyObject *) 0 ;
9860 PyObject *arg3 = (PyObject *) 0 ;
9861 void *argp1 = 0 ;
9862 int res1 = 0 ;
9863 PyObject * obj0 = 0 ;
9864 PyObject * obj1 = 0 ;
9865 PyObject * obj2 = 0 ;
9866 char * kwnames[] = {
9867 (char *) "self",(char *) "self",(char *) "_class", NULL
9868 };
9869
9870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9874 }
9875 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9876 arg2 = obj1;
9877 arg3 = obj2;
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 (arg1)->_setCallbackInfo(arg2,arg3);
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_Py_Void();
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj = 0;
9893 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9894 wxString *arg2 = 0 ;
9895 bool result;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 bool temp2 = false ;
9899 PyObject * obj0 = 0 ;
9900 PyObject * obj1 = 0 ;
9901 char * kwnames[] = {
9902 (char *) "self",(char *) "location", NULL
9903 };
9904
9905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9909 }
9910 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9911 {
9912 arg2 = wxString_in_helper(obj1);
9913 if (arg2 == NULL) SWIG_fail;
9914 temp2 = true;
9915 }
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9924 }
9925 {
9926 if (temp2)
9927 delete arg2;
9928 }
9929 return resultobj;
9930 fail:
9931 {
9932 if (temp2)
9933 delete arg2;
9934 }
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj = 0;
9941 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9942 wxFileSystem *arg2 = 0 ;
9943 wxString *arg3 = 0 ;
9944 wxFSFile *result = 0 ;
9945 void *argp1 = 0 ;
9946 int res1 = 0 ;
9947 void *argp2 = 0 ;
9948 int res2 = 0 ;
9949 bool temp3 = false ;
9950 PyObject * obj0 = 0 ;
9951 PyObject * obj1 = 0 ;
9952 PyObject * obj2 = 0 ;
9953 char * kwnames[] = {
9954 (char *) "self",(char *) "fs",(char *) "location", NULL
9955 };
9956
9957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9961 }
9962 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9963 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9964 if (!SWIG_IsOK(res2)) {
9965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9966 }
9967 if (!argp2) {
9968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9969 }
9970 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9971 {
9972 arg3 = wxString_in_helper(obj2);
9973 if (arg3 == NULL) SWIG_fail;
9974 temp3 = true;
9975 }
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9984 }
9985 {
9986 if (temp3)
9987 delete arg3;
9988 }
9989 return resultobj;
9990 fail:
9991 {
9992 if (temp3)
9993 delete arg3;
9994 }
9995 return NULL;
9996 }
9997
9998
9999 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10000 PyObject *resultobj = 0;
10001 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10002 wxString *arg2 = 0 ;
10003 int arg3 = (int) 0 ;
10004 wxString result;
10005 void *argp1 = 0 ;
10006 int res1 = 0 ;
10007 bool temp2 = false ;
10008 int val3 ;
10009 int ecode3 = 0 ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 PyObject * obj2 = 0 ;
10013 char * kwnames[] = {
10014 (char *) "self",(char *) "spec",(char *) "flags", NULL
10015 };
10016
10017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10021 }
10022 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10023 {
10024 arg2 = wxString_in_helper(obj1);
10025 if (arg2 == NULL) SWIG_fail;
10026 temp2 = true;
10027 }
10028 if (obj2) {
10029 ecode3 = SWIG_AsVal_int(obj2, &val3);
10030 if (!SWIG_IsOK(ecode3)) {
10031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10032 }
10033 arg3 = static_cast< int >(val3);
10034 }
10035 {
10036 PyThreadState* __tstate = wxPyBeginAllowThreads();
10037 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 {
10042 #if wxUSE_UNICODE
10043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10044 #else
10045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10046 #endif
10047 }
10048 {
10049 if (temp2)
10050 delete arg2;
10051 }
10052 return resultobj;
10053 fail:
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 return NULL;
10059 }
10060
10061
10062 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10063 PyObject *resultobj = 0;
10064 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10065 wxString result;
10066 void *argp1 = 0 ;
10067 int res1 = 0 ;
10068 PyObject *swig_obj[1] ;
10069
10070 if (!args) SWIG_fail;
10071 swig_obj[0] = args;
10072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10073 if (!SWIG_IsOK(res1)) {
10074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10075 }
10076 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (arg1)->FindNext();
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 #if wxUSE_UNICODE
10085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10086 #else
10087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10088 #endif
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = 0;
10098 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 bool temp2 = false ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "location", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 {
10117 arg2 = wxString_in_helper(obj1);
10118 if (arg2 == NULL) SWIG_fail;
10119 temp2 = true;
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (arg1)->GetProtocol((wxString const &)*arg2);
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 {
10128 #if wxUSE_UNICODE
10129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10130 #else
10131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10132 #endif
10133 }
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp2)
10142 delete arg2;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10149 PyObject *resultobj = 0;
10150 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10151 wxString *arg2 = 0 ;
10152 wxString result;
10153 void *argp1 = 0 ;
10154 int res1 = 0 ;
10155 bool temp2 = false ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 char * kwnames[] = {
10159 (char *) "self",(char *) "location", NULL
10160 };
10161
10162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10164 if (!SWIG_IsOK(res1)) {
10165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10166 }
10167 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10168 {
10169 arg2 = wxString_in_helper(obj1);
10170 if (arg2 == NULL) SWIG_fail;
10171 temp2 = true;
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj = 0;
10202 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10203 wxString *arg2 = 0 ;
10204 wxString result;
10205 void *argp1 = 0 ;
10206 int res1 = 0 ;
10207 bool temp2 = false ;
10208 PyObject * obj0 = 0 ;
10209 PyObject * obj1 = 0 ;
10210 char * kwnames[] = {
10211 (char *) "self",(char *) "location", NULL
10212 };
10213
10214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10216 if (!SWIG_IsOK(res1)) {
10217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10218 }
10219 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10220 {
10221 arg2 = wxString_in_helper(obj1);
10222 if (arg2 == NULL) SWIG_fail;
10223 temp2 = true;
10224 }
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 result = (arg1)->GetAnchor((wxString const &)*arg2);
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 {
10232 #if wxUSE_UNICODE
10233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10234 #else
10235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10236 #endif
10237 }
10238 {
10239 if (temp2)
10240 delete arg2;
10241 }
10242 return resultobj;
10243 fail:
10244 {
10245 if (temp2)
10246 delete arg2;
10247 }
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = 0;
10254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10255 wxString *arg2 = 0 ;
10256 wxString result;
10257 void *argp1 = 0 ;
10258 int res1 = 0 ;
10259 bool temp2 = false ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char * kwnames[] = {
10263 (char *) "self",(char *) "location", NULL
10264 };
10265
10266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10270 }
10271 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10272 {
10273 arg2 = wxString_in_helper(obj1);
10274 if (arg2 == NULL) SWIG_fail;
10275 temp2 = true;
10276 }
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 #if wxUSE_UNICODE
10285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10286 #else
10287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10288 #endif
10289 }
10290 {
10291 if (temp2)
10292 delete arg2;
10293 }
10294 return resultobj;
10295 fail:
10296 {
10297 if (temp2)
10298 delete arg2;
10299 }
10300 return NULL;
10301 }
10302
10303
10304 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj = 0;
10306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10307 wxString *arg2 = 0 ;
10308 wxString result;
10309 void *argp1 = 0 ;
10310 int res1 = 0 ;
10311 bool temp2 = false ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 char * kwnames[] = {
10315 (char *) "self",(char *) "location", NULL
10316 };
10317
10318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10320 if (!SWIG_IsOK(res1)) {
10321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10322 }
10323 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10324 {
10325 arg2 = wxString_in_helper(obj1);
10326 if (arg2 == NULL) SWIG_fail;
10327 temp2 = true;
10328 }
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 #if wxUSE_UNICODE
10337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10338 #else
10339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10340 #endif
10341 }
10342 {
10343 if (temp2)
10344 delete arg2;
10345 }
10346 return resultobj;
10347 fail:
10348 {
10349 if (temp2)
10350 delete arg2;
10351 }
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10357 PyObject *obj;
10358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10359 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10360 return SWIG_Py_Void();
10361 }
10362
10363 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10364 return SWIG_Python_InitShadowInstance(args);
10365 }
10366
10367 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10368 PyObject *resultobj = 0;
10369 wxFileSystem *result = 0 ;
10370
10371 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 result = (wxFileSystem *)new wxFileSystem();
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 {
10379 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10380 }
10381 return resultobj;
10382 fail:
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10388 PyObject *resultobj = 0;
10389 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 PyObject *swig_obj[1] ;
10393
10394 if (!args) SWIG_fail;
10395 swig_obj[0] = args;
10396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10399 }
10400 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10401 {
10402 PyThreadState* __tstate = wxPyBeginAllowThreads();
10403 delete arg1;
10404
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 resultobj = SWIG_Py_Void();
10409 return resultobj;
10410 fail:
10411 return NULL;
10412 }
10413
10414
10415 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10416 PyObject *resultobj = 0;
10417 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10418 wxString *arg2 = 0 ;
10419 bool arg3 = (bool) false ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 bool temp2 = false ;
10423 bool val3 ;
10424 int ecode3 = 0 ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10436 }
10437 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10438 {
10439 arg2 = wxString_in_helper(obj1);
10440 if (arg2 == NULL) SWIG_fail;
10441 temp2 = true;
10442 }
10443 if (obj2) {
10444 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10445 if (!SWIG_IsOK(ecode3)) {
10446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10447 }
10448 arg3 = static_cast< bool >(val3);
10449 }
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 resultobj = SWIG_Py_Void();
10457 {
10458 if (temp2)
10459 delete arg2;
10460 }
10461 return resultobj;
10462 fail:
10463 {
10464 if (temp2)
10465 delete arg2;
10466 }
10467 return NULL;
10468 }
10469
10470
10471 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10472 PyObject *resultobj = 0;
10473 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10474 wxString result;
10475 void *argp1 = 0 ;
10476 int res1 = 0 ;
10477 PyObject *swig_obj[1] ;
10478
10479 if (!args) SWIG_fail;
10480 swig_obj[0] = args;
10481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10482 if (!SWIG_IsOK(res1)) {
10483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10484 }
10485 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 result = (arg1)->GetPath();
10489 wxPyEndAllowThreads(__tstate);
10490 if (PyErr_Occurred()) SWIG_fail;
10491 }
10492 {
10493 #if wxUSE_UNICODE
10494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10495 #else
10496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10497 #endif
10498 }
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10508 wxString *arg2 = 0 ;
10509 wxFSFile *result = 0 ;
10510 void *argp1 = 0 ;
10511 int res1 = 0 ;
10512 bool temp2 = false ;
10513 PyObject * obj0 = 0 ;
10514 PyObject * obj1 = 0 ;
10515 char * kwnames[] = {
10516 (char *) "self",(char *) "location", NULL
10517 };
10518
10519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10521 if (!SWIG_IsOK(res1)) {
10522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10523 }
10524 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10525 {
10526 arg2 = wxString_in_helper(obj1);
10527 if (arg2 == NULL) SWIG_fail;
10528 temp2 = true;
10529 }
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 {
10537 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10538 }
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj = 0;
10555 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10556 wxString *arg2 = 0 ;
10557 int arg3 = (int) 0 ;
10558 wxString result;
10559 void *argp1 = 0 ;
10560 int res1 = 0 ;
10561 bool temp2 = false ;
10562 int val3 ;
10563 int ecode3 = 0 ;
10564 PyObject * obj0 = 0 ;
10565 PyObject * obj1 = 0 ;
10566 PyObject * obj2 = 0 ;
10567 char * kwnames[] = {
10568 (char *) "self",(char *) "spec",(char *) "flags", NULL
10569 };
10570
10571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10573 if (!SWIG_IsOK(res1)) {
10574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10575 }
10576 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 if (obj2) {
10583 ecode3 = SWIG_AsVal_int(obj2, &val3);
10584 if (!SWIG_IsOK(ecode3)) {
10585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10586 }
10587 arg3 = static_cast< int >(val3);
10588 }
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10592 wxPyEndAllowThreads(__tstate);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 {
10596 #if wxUSE_UNICODE
10597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10598 #else
10599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10600 #endif
10601 }
10602 {
10603 if (temp2)
10604 delete arg2;
10605 }
10606 return resultobj;
10607 fail:
10608 {
10609 if (temp2)
10610 delete arg2;
10611 }
10612 return NULL;
10613 }
10614
10615
10616 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10617 PyObject *resultobj = 0;
10618 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10619 wxString result;
10620 void *argp1 = 0 ;
10621 int res1 = 0 ;
10622 PyObject *swig_obj[1] ;
10623
10624 if (!args) SWIG_fail;
10625 swig_obj[0] = args;
10626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10627 if (!SWIG_IsOK(res1)) {
10628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10629 }
10630 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (arg1)->FindNext();
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 #if wxUSE_UNICODE
10639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10640 #else
10641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10642 #endif
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj = 0;
10652 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject * obj0 = 0 ;
10656 char * kwnames[] = {
10657 (char *) "handler", NULL
10658 };
10659
10660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10662 if (!SWIG_IsOK(res1)) {
10663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10664 }
10665 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 wxFileSystem::AddHandler(arg1);
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_Py_Void();
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10680 PyObject *resultobj = 0;
10681
10682 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 wxFileSystem::CleanUpHandlers();
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 resultobj = SWIG_Py_Void();
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj = 0;
10698 wxString *arg1 = 0 ;
10699 wxString result;
10700 bool temp1 = false ;
10701 PyObject * obj0 = 0 ;
10702 char * kwnames[] = {
10703 (char *) "filename", NULL
10704 };
10705
10706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10707 {
10708 arg1 = wxString_in_helper(obj0);
10709 if (arg1 == NULL) SWIG_fail;
10710 temp1 = true;
10711 }
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 #if wxUSE_UNICODE
10720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10721 #else
10722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10723 #endif
10724 }
10725 {
10726 if (temp1)
10727 delete arg1;
10728 }
10729 return resultobj;
10730 fail:
10731 {
10732 if (temp1)
10733 delete arg1;
10734 }
10735 return NULL;
10736 }
10737
10738
10739 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj = 0;
10741 wxString *arg1 = 0 ;
10742 wxString result;
10743 bool temp1 = false ;
10744 PyObject * obj0 = 0 ;
10745 char * kwnames[] = {
10746 (char *) "url", NULL
10747 };
10748
10749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10750 {
10751 arg1 = wxString_in_helper(obj0);
10752 if (arg1 == NULL) SWIG_fail;
10753 temp1 = true;
10754 }
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 #if wxUSE_UNICODE
10763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10764 #else
10765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10766 #endif
10767 }
10768 {
10769 if (temp1)
10770 delete arg1;
10771 }
10772 return resultobj;
10773 fail:
10774 {
10775 if (temp1)
10776 delete arg1;
10777 }
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *obj;
10784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10785 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10786 return SWIG_Py_Void();
10787 }
10788
10789 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10790 return SWIG_Python_InitShadowInstance(args);
10791 }
10792
10793 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxInternetFSHandler *result = 0 ;
10796
10797 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10798 {
10799 PyThreadState* __tstate = wxPyBeginAllowThreads();
10800 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj = 0;
10813 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10814 wxString *arg2 = 0 ;
10815 bool result;
10816 void *argp1 = 0 ;
10817 int res1 = 0 ;
10818 bool temp2 = false ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 char * kwnames[] = {
10822 (char *) "self",(char *) "location", NULL
10823 };
10824
10825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10827 if (!SWIG_IsOK(res1)) {
10828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10829 }
10830 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10831 {
10832 arg2 = wxString_in_helper(obj1);
10833 if (arg2 == NULL) SWIG_fail;
10834 temp2 = true;
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 {
10843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10844 }
10845 {
10846 if (temp2)
10847 delete arg2;
10848 }
10849 return resultobj;
10850 fail:
10851 {
10852 if (temp2)
10853 delete arg2;
10854 }
10855 return NULL;
10856 }
10857
10858
10859 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10860 PyObject *resultobj = 0;
10861 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10862 wxFileSystem *arg2 = 0 ;
10863 wxString *arg3 = 0 ;
10864 wxFSFile *result = 0 ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 void *argp2 = 0 ;
10868 int res2 = 0 ;
10869 bool temp3 = false ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 PyObject * obj2 = 0 ;
10873 char * kwnames[] = {
10874 (char *) "self",(char *) "fs",(char *) "location", NULL
10875 };
10876
10877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10881 }
10882 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10884 if (!SWIG_IsOK(res2)) {
10885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10886 }
10887 if (!argp2) {
10888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10889 }
10890 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10891 {
10892 arg3 = wxString_in_helper(obj2);
10893 if (arg3 == NULL) SWIG_fail;
10894 temp3 = true;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10899 wxPyEndAllowThreads(__tstate);
10900 if (PyErr_Occurred()) SWIG_fail;
10901 }
10902 {
10903 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10904 }
10905 {
10906 if (temp3)
10907 delete arg3;
10908 }
10909 return resultobj;
10910 fail:
10911 {
10912 if (temp3)
10913 delete arg3;
10914 }
10915 return NULL;
10916 }
10917
10918
10919 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10920 PyObject *obj;
10921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10922 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10923 return SWIG_Py_Void();
10924 }
10925
10926 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10927 return SWIG_Python_InitShadowInstance(args);
10928 }
10929
10930 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10931 PyObject *resultobj = 0;
10932 wxZipFSHandler *result = 0 ;
10933
10934 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 result = (wxZipFSHandler *)new wxZipFSHandler();
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10951 wxString *arg2 = 0 ;
10952 bool result;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 bool temp2 = false ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char * kwnames[] = {
10959 (char *) "self",(char *) "location", NULL
10960 };
10961
10962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10964 if (!SWIG_IsOK(res1)) {
10965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10966 }
10967 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10968 {
10969 arg2 = wxString_in_helper(obj1);
10970 if (arg2 == NULL) SWIG_fail;
10971 temp2 = true;
10972 }
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 {
10980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10981 }
10982 {
10983 if (temp2)
10984 delete arg2;
10985 }
10986 return resultobj;
10987 fail:
10988 {
10989 if (temp2)
10990 delete arg2;
10991 }
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = 0;
10998 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10999 wxFileSystem *arg2 = 0 ;
11000 wxString *arg3 = 0 ;
11001 wxFSFile *result = 0 ;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 void *argp2 = 0 ;
11005 int res2 = 0 ;
11006 bool temp3 = false ;
11007 PyObject * obj0 = 0 ;
11008 PyObject * obj1 = 0 ;
11009 PyObject * obj2 = 0 ;
11010 char * kwnames[] = {
11011 (char *) "self",(char *) "fs",(char *) "location", NULL
11012 };
11013
11014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11016 if (!SWIG_IsOK(res1)) {
11017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11018 }
11019 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11021 if (!SWIG_IsOK(res2)) {
11022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11023 }
11024 if (!argp2) {
11025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11026 }
11027 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11028 {
11029 arg3 = wxString_in_helper(obj2);
11030 if (arg3 == NULL) SWIG_fail;
11031 temp3 = true;
11032 }
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11041 }
11042 {
11043 if (temp3)
11044 delete arg3;
11045 }
11046 return resultobj;
11047 fail:
11048 {
11049 if (temp3)
11050 delete arg3;
11051 }
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj = 0;
11058 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11059 wxString *arg2 = 0 ;
11060 int arg3 = (int) 0 ;
11061 wxString result;
11062 void *argp1 = 0 ;
11063 int res1 = 0 ;
11064 bool temp2 = false ;
11065 int val3 ;
11066 int ecode3 = 0 ;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 PyObject * obj2 = 0 ;
11070 char * kwnames[] = {
11071 (char *) "self",(char *) "spec",(char *) "flags", NULL
11072 };
11073
11074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11078 }
11079 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11080 {
11081 arg2 = wxString_in_helper(obj1);
11082 if (arg2 == NULL) SWIG_fail;
11083 temp2 = true;
11084 }
11085 if (obj2) {
11086 ecode3 = SWIG_AsVal_int(obj2, &val3);
11087 if (!SWIG_IsOK(ecode3)) {
11088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11089 }
11090 arg3 = static_cast< int >(val3);
11091 }
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 #if wxUSE_UNICODE
11100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11101 #else
11102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11103 #endif
11104 }
11105 {
11106 if (temp2)
11107 delete arg2;
11108 }
11109 return resultobj;
11110 fail:
11111 {
11112 if (temp2)
11113 delete arg2;
11114 }
11115 return NULL;
11116 }
11117
11118
11119 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11120 PyObject *resultobj = 0;
11121 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11122 wxString result;
11123 void *argp1 = 0 ;
11124 int res1 = 0 ;
11125 PyObject *swig_obj[1] ;
11126
11127 if (!args) SWIG_fail;
11128 swig_obj[0] = args;
11129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11132 }
11133 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (arg1)->FindNext();
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 #if wxUSE_UNICODE
11142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11143 #else
11144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11145 #endif
11146 }
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154 PyObject *obj;
11155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11156 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11157 return SWIG_Py_Void();
11158 }
11159
11160 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11161 return SWIG_Python_InitShadowInstance(args);
11162 }
11163
11164 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj = 0;
11166 wxString *arg1 = 0 ;
11167 wxImage *arg2 = 0 ;
11168 long arg3 ;
11169 bool temp1 = false ;
11170 void *argp2 = 0 ;
11171 int res2 = 0 ;
11172 long val3 ;
11173 int ecode3 = 0 ;
11174 PyObject * obj0 = 0 ;
11175 PyObject * obj1 = 0 ;
11176 PyObject * obj2 = 0 ;
11177 char * kwnames[] = {
11178 (char *) "filename",(char *) "image",(char *) "type", NULL
11179 };
11180
11181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11182 {
11183 arg1 = wxString_in_helper(obj0);
11184 if (arg1 == NULL) SWIG_fail;
11185 temp1 = true;
11186 }
11187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11188 if (!SWIG_IsOK(res2)) {
11189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11190 }
11191 if (!argp2) {
11192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11193 }
11194 arg2 = reinterpret_cast< wxImage * >(argp2);
11195 ecode3 = SWIG_AsVal_long(obj2, &val3);
11196 if (!SWIG_IsOK(ecode3)) {
11197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11198 }
11199 arg3 = static_cast< long >(val3);
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 resultobj = SWIG_Py_Void();
11207 {
11208 if (temp1)
11209 delete arg1;
11210 }
11211 return resultobj;
11212 fail:
11213 {
11214 if (temp1)
11215 delete arg1;
11216 }
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 wxString *arg1 = 0 ;
11224 wxBitmap *arg2 = 0 ;
11225 long arg3 ;
11226 bool temp1 = false ;
11227 void *argp2 = 0 ;
11228 int res2 = 0 ;
11229 long val3 ;
11230 int ecode3 = 0 ;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 PyObject * obj2 = 0 ;
11234 char * kwnames[] = {
11235 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11236 };
11237
11238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11239 {
11240 arg1 = wxString_in_helper(obj0);
11241 if (arg1 == NULL) SWIG_fail;
11242 temp1 = true;
11243 }
11244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11245 if (!SWIG_IsOK(res2)) {
11246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11247 }
11248 if (!argp2) {
11249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11250 }
11251 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11252 ecode3 = SWIG_AsVal_long(obj2, &val3);
11253 if (!SWIG_IsOK(ecode3)) {
11254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11255 }
11256 arg3 = static_cast< long >(val3);
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 resultobj = SWIG_Py_Void();
11264 {
11265 if (temp1)
11266 delete arg1;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (temp1)
11272 delete arg1;
11273 }
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = 0;
11280 wxString *arg1 = 0 ;
11281 PyObject *arg2 = (PyObject *) 0 ;
11282 bool temp1 = false ;
11283 PyObject * obj0 = 0 ;
11284 PyObject * obj1 = 0 ;
11285 char * kwnames[] = {
11286 (char *) "filename",(char *) "data", NULL
11287 };
11288
11289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11290 {
11291 arg1 = wxString_in_helper(obj0);
11292 if (arg1 == NULL) SWIG_fail;
11293 temp1 = true;
11294 }
11295 arg2 = obj1;
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 resultobj = SWIG_Py_Void();
11303 {
11304 if (temp1)
11305 delete arg1;
11306 }
11307 return resultobj;
11308 fail:
11309 {
11310 if (temp1)
11311 delete arg1;
11312 }
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *resultobj = 0;
11319 wxMemoryFSHandler *result = 0 ;
11320
11321 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11329 return resultobj;
11330 fail:
11331 return NULL;
11332 }
11333
11334
11335 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj = 0;
11337 wxString *arg1 = 0 ;
11338 bool temp1 = false ;
11339 PyObject * obj0 = 0 ;
11340 char * kwnames[] = {
11341 (char *) "filename", NULL
11342 };
11343
11344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11345 {
11346 arg1 = wxString_in_helper(obj0);
11347 if (arg1 == NULL) SWIG_fail;
11348 temp1 = true;
11349 }
11350 {
11351 PyThreadState* __tstate = wxPyBeginAllowThreads();
11352 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 resultobj = SWIG_Py_Void();
11357 {
11358 if (temp1)
11359 delete arg1;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp1)
11365 delete arg1;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj = 0;
11373 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11374 wxString *arg2 = 0 ;
11375 bool result;
11376 void *argp1 = 0 ;
11377 int res1 = 0 ;
11378 bool temp2 = false ;
11379 PyObject * obj0 = 0 ;
11380 PyObject * obj1 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "self",(char *) "location", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11387 if (!SWIG_IsOK(res1)) {
11388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11389 }
11390 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11391 {
11392 arg2 = wxString_in_helper(obj1);
11393 if (arg2 == NULL) SWIG_fail;
11394 temp2 = true;
11395 }
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 {
11406 if (temp2)
11407 delete arg2;
11408 }
11409 return resultobj;
11410 fail:
11411 {
11412 if (temp2)
11413 delete arg2;
11414 }
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11420 PyObject *resultobj = 0;
11421 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11422 wxFileSystem *arg2 = 0 ;
11423 wxString *arg3 = 0 ;
11424 wxFSFile *result = 0 ;
11425 void *argp1 = 0 ;
11426 int res1 = 0 ;
11427 void *argp2 = 0 ;
11428 int res2 = 0 ;
11429 bool temp3 = false ;
11430 PyObject * obj0 = 0 ;
11431 PyObject * obj1 = 0 ;
11432 PyObject * obj2 = 0 ;
11433 char * kwnames[] = {
11434 (char *) "self",(char *) "fs",(char *) "location", NULL
11435 };
11436
11437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11439 if (!SWIG_IsOK(res1)) {
11440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11441 }
11442 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11443 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11444 if (!SWIG_IsOK(res2)) {
11445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11446 }
11447 if (!argp2) {
11448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11449 }
11450 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11451 {
11452 arg3 = wxString_in_helper(obj2);
11453 if (arg3 == NULL) SWIG_fail;
11454 temp3 = true;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 {
11463 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11464 }
11465 {
11466 if (temp3)
11467 delete arg3;
11468 }
11469 return resultobj;
11470 fail:
11471 {
11472 if (temp3)
11473 delete arg3;
11474 }
11475 return NULL;
11476 }
11477
11478
11479 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11480 PyObject *resultobj = 0;
11481 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11482 wxString *arg2 = 0 ;
11483 int arg3 = (int) 0 ;
11484 wxString result;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 bool temp2 = false ;
11488 int val3 ;
11489 int ecode3 = 0 ;
11490 PyObject * obj0 = 0 ;
11491 PyObject * obj1 = 0 ;
11492 PyObject * obj2 = 0 ;
11493 char * kwnames[] = {
11494 (char *) "self",(char *) "spec",(char *) "flags", NULL
11495 };
11496
11497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11499 if (!SWIG_IsOK(res1)) {
11500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11501 }
11502 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11503 {
11504 arg2 = wxString_in_helper(obj1);
11505 if (arg2 == NULL) SWIG_fail;
11506 temp2 = true;
11507 }
11508 if (obj2) {
11509 ecode3 = SWIG_AsVal_int(obj2, &val3);
11510 if (!SWIG_IsOK(ecode3)) {
11511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11512 }
11513 arg3 = static_cast< int >(val3);
11514 }
11515 {
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 {
11522 #if wxUSE_UNICODE
11523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11524 #else
11525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11526 #endif
11527 }
11528 {
11529 if (temp2)
11530 delete arg2;
11531 }
11532 return resultobj;
11533 fail:
11534 {
11535 if (temp2)
11536 delete arg2;
11537 }
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11543 PyObject *resultobj = 0;
11544 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11545 wxString result;
11546 void *argp1 = 0 ;
11547 int res1 = 0 ;
11548 PyObject *swig_obj[1] ;
11549
11550 if (!args) SWIG_fail;
11551 swig_obj[0] = args;
11552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11553 if (!SWIG_IsOK(res1)) {
11554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11555 }
11556 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11557 {
11558 PyThreadState* __tstate = wxPyBeginAllowThreads();
11559 result = (arg1)->FindNext();
11560 wxPyEndAllowThreads(__tstate);
11561 if (PyErr_Occurred()) SWIG_fail;
11562 }
11563 {
11564 #if wxUSE_UNICODE
11565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11566 #else
11567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11568 #endif
11569 }
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11577 PyObject *obj;
11578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11579 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11580 return SWIG_Py_Void();
11581 }
11582
11583 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11584 return SWIG_Python_InitShadowInstance(args);
11585 }
11586
11587 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *resultobj = 0;
11589 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11590 wxString result;
11591 void *argp1 = 0 ;
11592 int res1 = 0 ;
11593 PyObject *swig_obj[1] ;
11594
11595 if (!args) SWIG_fail;
11596 swig_obj[0] = args;
11597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11600 }
11601 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 result = (arg1)->GetName();
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 #if wxUSE_UNICODE
11610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11611 #else
11612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11613 #endif
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11622 PyObject *resultobj = 0;
11623 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11624 wxString result;
11625 void *argp1 = 0 ;
11626 int res1 = 0 ;
11627 PyObject *swig_obj[1] ;
11628
11629 if (!args) SWIG_fail;
11630 swig_obj[0] = args;
11631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11632 if (!SWIG_IsOK(res1)) {
11633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11634 }
11635 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 result = (arg1)->GetExtension();
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 #if wxUSE_UNICODE
11644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11645 #else
11646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11647 #endif
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 PyObject *resultobj = 0;
11657 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11658 long result;
11659 void *argp1 = 0 ;
11660 int res1 = 0 ;
11661 PyObject *swig_obj[1] ;
11662
11663 if (!args) SWIG_fail;
11664 swig_obj[0] = args;
11665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11666 if (!SWIG_IsOK(res1)) {
11667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11668 }
11669 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11670 {
11671 PyThreadState* __tstate = wxPyBeginAllowThreads();
11672 result = (long)(arg1)->GetType();
11673 wxPyEndAllowThreads(__tstate);
11674 if (PyErr_Occurred()) SWIG_fail;
11675 }
11676 resultobj = SWIG_From_long(static_cast< long >(result));
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11686 wxString result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 PyObject *swig_obj[1] ;
11690
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11696 }
11697 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (arg1)->GetMimeType();
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 {
11705 #if wxUSE_UNICODE
11706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11707 #else
11708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11709 #endif
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj = 0;
11719 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11720 wxString *arg2 = 0 ;
11721 bool result;
11722 void *argp1 = 0 ;
11723 int res1 = 0 ;
11724 bool temp2 = false ;
11725 PyObject * obj0 = 0 ;
11726 PyObject * obj1 = 0 ;
11727 char * kwnames[] = {
11728 (char *) "self",(char *) "name", NULL
11729 };
11730
11731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11735 }
11736 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11737 {
11738 arg2 = wxString_in_helper(obj1);
11739 if (arg2 == NULL) SWIG_fail;
11740 temp2 = true;
11741 }
11742 {
11743 PyThreadState* __tstate = wxPyBeginAllowThreads();
11744 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 {
11749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11750 }
11751 {
11752 if (temp2)
11753 delete arg2;
11754 }
11755 return resultobj;
11756 fail:
11757 {
11758 if (temp2)
11759 delete arg2;
11760 }
11761 return NULL;
11762 }
11763
11764
11765 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj = 0;
11767 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11768 wxString *arg2 = 0 ;
11769 void *argp1 = 0 ;
11770 int res1 = 0 ;
11771 bool temp2 = false ;
11772 PyObject * obj0 = 0 ;
11773 PyObject * obj1 = 0 ;
11774 char * kwnames[] = {
11775 (char *) "self",(char *) "name", NULL
11776 };
11777
11778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11782 }
11783 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11784 {
11785 arg2 = wxString_in_helper(obj1);
11786 if (arg2 == NULL) SWIG_fail;
11787 temp2 = true;
11788 }
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 (arg1)->SetName((wxString const &)*arg2);
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 resultobj = SWIG_Py_Void();
11796 {
11797 if (temp2)
11798 delete arg2;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (temp2)
11804 delete arg2;
11805 }
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj = 0;
11812 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11813 wxString *arg2 = 0 ;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 bool temp2 = false ;
11817 PyObject * obj0 = 0 ;
11818 PyObject * obj1 = 0 ;
11819 char * kwnames[] = {
11820 (char *) "self",(char *) "extension", NULL
11821 };
11822
11823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11825 if (!SWIG_IsOK(res1)) {
11826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11827 }
11828 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11829 {
11830 arg2 = wxString_in_helper(obj1);
11831 if (arg2 == NULL) SWIG_fail;
11832 temp2 = true;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 (arg1)->SetExtension((wxString const &)*arg2);
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 resultobj = SWIG_Py_Void();
11841 {
11842 if (temp2)
11843 delete arg2;
11844 }
11845 return resultobj;
11846 fail:
11847 {
11848 if (temp2)
11849 delete arg2;
11850 }
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11856 PyObject *resultobj = 0;
11857 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11858 long arg2 ;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 long val2 ;
11862 int ecode2 = 0 ;
11863 PyObject * obj0 = 0 ;
11864 PyObject * obj1 = 0 ;
11865 char * kwnames[] = {
11866 (char *) "self",(char *) "type", NULL
11867 };
11868
11869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11871 if (!SWIG_IsOK(res1)) {
11872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11873 }
11874 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11875 ecode2 = SWIG_AsVal_long(obj1, &val2);
11876 if (!SWIG_IsOK(ecode2)) {
11877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11878 }
11879 arg2 = static_cast< long >(val2);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 (arg1)->SetType(arg2);
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_Py_Void();
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj = 0;
11895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11896 wxString *arg2 = 0 ;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 bool temp2 = false ;
11900 PyObject * obj0 = 0 ;
11901 PyObject * obj1 = 0 ;
11902 char * kwnames[] = {
11903 (char *) "self",(char *) "mimetype", NULL
11904 };
11905
11906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11910 }
11911 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11912 {
11913 arg2 = wxString_in_helper(obj1);
11914 if (arg2 == NULL) SWIG_fail;
11915 temp2 = true;
11916 }
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 (arg1)->SetMimeType((wxString const &)*arg2);
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 resultobj = SWIG_Py_Void();
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return resultobj;
11929 fail:
11930 {
11931 if (temp2)
11932 delete arg2;
11933 }
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 PyObject *obj;
11940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11941 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11942 return SWIG_Py_Void();
11943 }
11944
11945 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 PyObject *resultobj = 0;
11947 wxPyImageHandler *result = 0 ;
11948
11949 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (wxPyImageHandler *)new wxPyImageHandler();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj = 0;
11965 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11966 PyObject *arg2 = (PyObject *) 0 ;
11967 void *argp1 = 0 ;
11968 int res1 = 0 ;
11969 PyObject * obj0 = 0 ;
11970 PyObject * obj1 = 0 ;
11971 char * kwnames[] = {
11972 (char *) "self",(char *) "self", NULL
11973 };
11974
11975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11977 if (!SWIG_IsOK(res1)) {
11978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11979 }
11980 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11981 arg2 = obj1;
11982 {
11983 PyThreadState* __tstate = wxPyBeginAllowThreads();
11984 (arg1)->_SetSelf(arg2);
11985 wxPyEndAllowThreads(__tstate);
11986 if (PyErr_Occurred()) SWIG_fail;
11987 }
11988 resultobj = SWIG_Py_Void();
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11996 PyObject *obj;
11997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
11999 return SWIG_Py_Void();
12000 }
12001
12002 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12003 return SWIG_Python_InitShadowInstance(args);
12004 }
12005
12006 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 PyObject *resultobj = 0;
12008 wxImageHistogram *result = 0 ;
12009
12010 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (wxImageHistogram *)new wxImageHistogram();
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj = 0;
12026 byte arg1 ;
12027 byte arg2 ;
12028 byte arg3 ;
12029 unsigned long result;
12030 unsigned char val1 ;
12031 int ecode1 = 0 ;
12032 unsigned char val2 ;
12033 int ecode2 = 0 ;
12034 unsigned char val3 ;
12035 int ecode3 = 0 ;
12036 PyObject * obj0 = 0 ;
12037 PyObject * obj1 = 0 ;
12038 PyObject * obj2 = 0 ;
12039 char * kwnames[] = {
12040 (char *) "r",(char *) "g",(char *) "b", NULL
12041 };
12042
12043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12044 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12045 if (!SWIG_IsOK(ecode1)) {
12046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12047 }
12048 arg1 = static_cast< byte >(val1);
12049 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12050 if (!SWIG_IsOK(ecode2)) {
12051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12052 }
12053 arg2 = static_cast< byte >(val2);
12054 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12055 if (!SWIG_IsOK(ecode3)) {
12056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12057 }
12058 arg3 = static_cast< byte >(val3);
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj = 0;
12074 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12075 byte *arg2 = (byte *) 0 ;
12076 byte *arg3 = (byte *) 0 ;
12077 byte *arg4 = (byte *) 0 ;
12078 byte arg5 = (byte) 1 ;
12079 byte arg6 = (byte) 0 ;
12080 byte arg7 = (byte) 0 ;
12081 bool result;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 byte temp2 ;
12085 int res2 = SWIG_TMPOBJ ;
12086 byte temp3 ;
12087 int res3 = SWIG_TMPOBJ ;
12088 byte temp4 ;
12089 int res4 = SWIG_TMPOBJ ;
12090 unsigned char val5 ;
12091 int ecode5 = 0 ;
12092 unsigned char val6 ;
12093 int ecode6 = 0 ;
12094 unsigned char val7 ;
12095 int ecode7 = 0 ;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 PyObject * obj2 = 0 ;
12099 PyObject * obj3 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12102 };
12103
12104 arg2 = &temp2;
12105 arg3 = &temp3;
12106 arg4 = &temp4;
12107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12111 }
12112 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12113 if (obj1) {
12114 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12115 if (!SWIG_IsOK(ecode5)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12117 }
12118 arg5 = static_cast< byte >(val5);
12119 }
12120 if (obj2) {
12121 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12122 if (!SWIG_IsOK(ecode6)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12124 }
12125 arg6 = static_cast< byte >(val6);
12126 }
12127 if (obj3) {
12128 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12129 if (!SWIG_IsOK(ecode7)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12131 }
12132 arg7 = static_cast< byte >(val7);
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12137 wxPyEndAllowThreads(__tstate);
12138 if (PyErr_Occurred()) SWIG_fail;
12139 }
12140 {
12141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12142 }
12143 if (SWIG_IsTmpObj(res2)) {
12144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12145 } else {
12146 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12148 }
12149 if (SWIG_IsTmpObj(res3)) {
12150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12151 } else {
12152 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12154 }
12155 if (SWIG_IsTmpObj(res4)) {
12156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12157 } else {
12158 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12160 }
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj = 0;
12169 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12170 unsigned long arg2 ;
12171 unsigned long result;
12172 void *argp1 = 0 ;
12173 int res1 = 0 ;
12174 unsigned long val2 ;
12175 int ecode2 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "key", NULL
12180 };
12181
12182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12186 }
12187 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12188 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12189 if (!SWIG_IsOK(ecode2)) {
12190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12191 }
12192 arg2 = static_cast< unsigned long >(val2);
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj = 0;
12208 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12209 byte arg2 ;
12210 byte arg3 ;
12211 byte arg4 ;
12212 unsigned long result;
12213 void *argp1 = 0 ;
12214 int res1 = 0 ;
12215 unsigned char val2 ;
12216 int ecode2 = 0 ;
12217 unsigned char val3 ;
12218 int ecode3 = 0 ;
12219 unsigned char val4 ;
12220 int ecode4 = 0 ;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 PyObject * obj2 = 0 ;
12224 PyObject * obj3 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12235 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12236 if (!SWIG_IsOK(ecode2)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12238 }
12239 arg2 = static_cast< byte >(val2);
12240 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12241 if (!SWIG_IsOK(ecode3)) {
12242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12243 }
12244 arg3 = static_cast< byte >(val3);
12245 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12246 if (!SWIG_IsOK(ecode4)) {
12247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12248 }
12249 arg4 = static_cast< byte >(val4);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12266 wxColour *arg2 = 0 ;
12267 unsigned long result;
12268 void *argp1 = 0 ;
12269 int res1 = 0 ;
12270 wxColour temp2 ;
12271 PyObject * obj0 = 0 ;
12272 PyObject * obj1 = 0 ;
12273 char * kwnames[] = {
12274 (char *) "self",(char *) "colour", NULL
12275 };
12276
12277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12281 }
12282 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12283 {
12284 arg2 = &temp2;
12285 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12286 }
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12301 PyObject *obj;
12302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12303 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12304 return SWIG_Py_Void();
12305 }
12306
12307 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12308 return SWIG_Python_InitShadowInstance(args);
12309 }
12310
12311 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 byte arg1 = (byte) 0 ;
12314 byte arg2 = (byte) 0 ;
12315 byte arg3 = (byte) 0 ;
12316 wxImage_RGBValue *result = 0 ;
12317 unsigned char val1 ;
12318 int ecode1 = 0 ;
12319 unsigned char val2 ;
12320 int ecode2 = 0 ;
12321 unsigned char val3 ;
12322 int ecode3 = 0 ;
12323 PyObject * obj0 = 0 ;
12324 PyObject * obj1 = 0 ;
12325 PyObject * obj2 = 0 ;
12326 char * kwnames[] = {
12327 (char *) "r",(char *) "g",(char *) "b", NULL
12328 };
12329
12330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12331 if (obj0) {
12332 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12333 if (!SWIG_IsOK(ecode1)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12335 }
12336 arg1 = static_cast< byte >(val1);
12337 }
12338 if (obj1) {
12339 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12340 if (!SWIG_IsOK(ecode2)) {
12341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12342 }
12343 arg2 = static_cast< byte >(val2);
12344 }
12345 if (obj2) {
12346 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12347 if (!SWIG_IsOK(ecode3)) {
12348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12349 }
12350 arg3 = static_cast< byte >(val3);
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12368 byte arg2 ;
12369 void *argp1 = 0 ;
12370 int res1 = 0 ;
12371 unsigned char val2 ;
12372 int ecode2 = 0 ;
12373 PyObject *swig_obj[2] ;
12374
12375 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12377 if (!SWIG_IsOK(res1)) {
12378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12379 }
12380 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12381 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12382 if (!SWIG_IsOK(ecode2)) {
12383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12384 }
12385 arg2 = static_cast< byte >(val2);
12386 if (arg1) (arg1)->red = arg2;
12387
12388 resultobj = SWIG_Py_Void();
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *resultobj = 0;
12397 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12398 byte result;
12399 void *argp1 = 0 ;
12400 int res1 = 0 ;
12401 PyObject *swig_obj[1] ;
12402
12403 if (!args) SWIG_fail;
12404 swig_obj[0] = args;
12405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12406 if (!SWIG_IsOK(res1)) {
12407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12408 }
12409 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12410 result = (byte) ((arg1)->red);
12411 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12419 PyObject *resultobj = 0;
12420 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12421 byte arg2 ;
12422 void *argp1 = 0 ;
12423 int res1 = 0 ;
12424 unsigned char val2 ;
12425 int ecode2 = 0 ;
12426 PyObject *swig_obj[2] ;
12427
12428 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12432 }
12433 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12434 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12437 }
12438 arg2 = static_cast< byte >(val2);
12439 if (arg1) (arg1)->green = arg2;
12440
12441 resultobj = SWIG_Py_Void();
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12451 byte result;
12452 void *argp1 = 0 ;
12453 int res1 = 0 ;
12454 PyObject *swig_obj[1] ;
12455
12456 if (!args) SWIG_fail;
12457 swig_obj[0] = args;
12458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12459 if (!SWIG_IsOK(res1)) {
12460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12461 }
12462 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12463 result = (byte) ((arg1)->green);
12464 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12472 PyObject *resultobj = 0;
12473 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12474 byte arg2 ;
12475 void *argp1 = 0 ;
12476 int res1 = 0 ;
12477 unsigned char val2 ;
12478 int ecode2 = 0 ;
12479 PyObject *swig_obj[2] ;
12480
12481 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12487 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12488 if (!SWIG_IsOK(ecode2)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12490 }
12491 arg2 = static_cast< byte >(val2);
12492 if (arg1) (arg1)->blue = arg2;
12493
12494 resultobj = SWIG_Py_Void();
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12502 PyObject *resultobj = 0;
12503 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12504 byte result;
12505 void *argp1 = 0 ;
12506 int res1 = 0 ;
12507 PyObject *swig_obj[1] ;
12508
12509 if (!args) SWIG_fail;
12510 swig_obj[0] = args;
12511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12512 if (!SWIG_IsOK(res1)) {
12513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12514 }
12515 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12516 result = (byte) ((arg1)->blue);
12517 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12525 PyObject *obj;
12526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12527 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12528 return SWIG_Py_Void();
12529 }
12530
12531 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 return SWIG_Python_InitShadowInstance(args);
12533 }
12534
12535 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 double arg1 = (double) 0.0 ;
12538 double arg2 = (double) 0.0 ;
12539 double arg3 = (double) 0.0 ;
12540 wxImage_HSVValue *result = 0 ;
12541 double val1 ;
12542 int ecode1 = 0 ;
12543 double val2 ;
12544 int ecode2 = 0 ;
12545 double val3 ;
12546 int ecode3 = 0 ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 PyObject * obj2 = 0 ;
12550 char * kwnames[] = {
12551 (char *) "h",(char *) "s",(char *) "v", NULL
12552 };
12553
12554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12555 if (obj0) {
12556 ecode1 = SWIG_AsVal_double(obj0, &val1);
12557 if (!SWIG_IsOK(ecode1)) {
12558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12559 }
12560 arg1 = static_cast< double >(val1);
12561 }
12562 if (obj1) {
12563 ecode2 = SWIG_AsVal_double(obj1, &val2);
12564 if (!SWIG_IsOK(ecode2)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12566 }
12567 arg2 = static_cast< double >(val2);
12568 }
12569 if (obj2) {
12570 ecode3 = SWIG_AsVal_double(obj2, &val3);
12571 if (!SWIG_IsOK(ecode3)) {
12572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12573 }
12574 arg3 = static_cast< double >(val3);
12575 }
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12583 return resultobj;
12584 fail:
12585 return NULL;
12586 }
12587
12588
12589 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12590 PyObject *resultobj = 0;
12591 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12592 double arg2 ;
12593 void *argp1 = 0 ;
12594 int res1 = 0 ;
12595 double val2 ;
12596 int ecode2 = 0 ;
12597 PyObject *swig_obj[2] ;
12598
12599 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12601 if (!SWIG_IsOK(res1)) {
12602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12603 }
12604 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12605 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12606 if (!SWIG_IsOK(ecode2)) {
12607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12608 }
12609 arg2 = static_cast< double >(val2);
12610 if (arg1) (arg1)->hue = arg2;
12611
12612 resultobj = SWIG_Py_Void();
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12620 PyObject *resultobj = 0;
12621 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12622 double result;
12623 void *argp1 = 0 ;
12624 int res1 = 0 ;
12625 PyObject *swig_obj[1] ;
12626
12627 if (!args) SWIG_fail;
12628 swig_obj[0] = args;
12629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12630 if (!SWIG_IsOK(res1)) {
12631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12632 }
12633 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12634 result = (double) ((arg1)->hue);
12635 resultobj = SWIG_From_double(static_cast< double >(result));
12636 return resultobj;
12637 fail:
12638 return NULL;
12639 }
12640
12641
12642 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12643 PyObject *resultobj = 0;
12644 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12645 double arg2 ;
12646 void *argp1 = 0 ;
12647 int res1 = 0 ;
12648 double val2 ;
12649 int ecode2 = 0 ;
12650 PyObject *swig_obj[2] ;
12651
12652 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12656 }
12657 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12658 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12661 }
12662 arg2 = static_cast< double >(val2);
12663 if (arg1) (arg1)->saturation = arg2;
12664
12665 resultobj = SWIG_Py_Void();
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12675 double result;
12676 void *argp1 = 0 ;
12677 int res1 = 0 ;
12678 PyObject *swig_obj[1] ;
12679
12680 if (!args) SWIG_fail;
12681 swig_obj[0] = args;
12682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12683 if (!SWIG_IsOK(res1)) {
12684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12685 }
12686 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12687 result = (double) ((arg1)->saturation);
12688 resultobj = SWIG_From_double(static_cast< double >(result));
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12696 PyObject *resultobj = 0;
12697 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12698 double arg2 ;
12699 void *argp1 = 0 ;
12700 int res1 = 0 ;
12701 double val2 ;
12702 int ecode2 = 0 ;
12703 PyObject *swig_obj[2] ;
12704
12705 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12707 if (!SWIG_IsOK(res1)) {
12708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12709 }
12710 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12711 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12712 if (!SWIG_IsOK(ecode2)) {
12713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12714 }
12715 arg2 = static_cast< double >(val2);
12716 if (arg1) (arg1)->value = arg2;
12717
12718 resultobj = SWIG_Py_Void();
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726 PyObject *resultobj = 0;
12727 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12728 double result;
12729 void *argp1 = 0 ;
12730 int res1 = 0 ;
12731 PyObject *swig_obj[1] ;
12732
12733 if (!args) SWIG_fail;
12734 swig_obj[0] = args;
12735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12736 if (!SWIG_IsOK(res1)) {
12737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12738 }
12739 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12740 result = (double) ((arg1)->value);
12741 resultobj = SWIG_From_double(static_cast< double >(result));
12742 return resultobj;
12743 fail:
12744 return NULL;
12745 }
12746
12747
12748 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 PyObject *obj;
12750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12751 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12752 return SWIG_Py_Void();
12753 }
12754
12755 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12756 return SWIG_Python_InitShadowInstance(args);
12757 }
12758
12759 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj = 0;
12761 wxString *arg1 = 0 ;
12762 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12763 int arg3 = (int) -1 ;
12764 wxImage *result = 0 ;
12765 bool temp1 = false ;
12766 long val2 ;
12767 int ecode2 = 0 ;
12768 int val3 ;
12769 int ecode3 = 0 ;
12770 PyObject * obj0 = 0 ;
12771 PyObject * obj1 = 0 ;
12772 PyObject * obj2 = 0 ;
12773 char * kwnames[] = {
12774 (char *) "name",(char *) "type",(char *) "index", NULL
12775 };
12776
12777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12778 {
12779 arg1 = wxString_in_helper(obj0);
12780 if (arg1 == NULL) SWIG_fail;
12781 temp1 = true;
12782 }
12783 if (obj1) {
12784 ecode2 = SWIG_AsVal_long(obj1, &val2);
12785 if (!SWIG_IsOK(ecode2)) {
12786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12787 }
12788 arg2 = static_cast< long >(val2);
12789 }
12790 if (obj2) {
12791 ecode3 = SWIG_AsVal_int(obj2, &val3);
12792 if (!SWIG_IsOK(ecode3)) {
12793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12794 }
12795 arg3 = static_cast< int >(val3);
12796 }
12797 {
12798 PyThreadState* __tstate = wxPyBeginAllowThreads();
12799 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12804 {
12805 if (temp1)
12806 delete arg1;
12807 }
12808 return resultobj;
12809 fail:
12810 {
12811 if (temp1)
12812 delete arg1;
12813 }
12814 return NULL;
12815 }
12816
12817
12818 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 PyObject *resultobj = 0;
12820 wxImage *arg1 = (wxImage *) 0 ;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 PyObject *swig_obj[1] ;
12824
12825 if (!args) SWIG_fail;
12826 swig_obj[0] = args;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12830 }
12831 arg1 = reinterpret_cast< wxImage * >(argp1);
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 delete arg1;
12835
12836 wxPyEndAllowThreads(__tstate);
12837 if (PyErr_Occurred()) SWIG_fail;
12838 }
12839 resultobj = SWIG_Py_Void();
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12847 PyObject *resultobj = 0;
12848 wxString *arg1 = 0 ;
12849 wxString *arg2 = 0 ;
12850 int arg3 = (int) -1 ;
12851 wxImage *result = 0 ;
12852 bool temp1 = false ;
12853 bool temp2 = false ;
12854 int val3 ;
12855 int ecode3 = 0 ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 PyObject * obj2 = 0 ;
12859 char * kwnames[] = {
12860 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12861 };
12862
12863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12864 {
12865 arg1 = wxString_in_helper(obj0);
12866 if (arg1 == NULL) SWIG_fail;
12867 temp1 = true;
12868 }
12869 {
12870 arg2 = wxString_in_helper(obj1);
12871 if (arg2 == NULL) SWIG_fail;
12872 temp2 = true;
12873 }
12874 if (obj2) {
12875 ecode3 = SWIG_AsVal_int(obj2, &val3);
12876 if (!SWIG_IsOK(ecode3)) {
12877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12878 }
12879 arg3 = static_cast< int >(val3);
12880 }
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12888 {
12889 if (temp1)
12890 delete arg1;
12891 }
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 return resultobj;
12897 fail:
12898 {
12899 if (temp1)
12900 delete arg1;
12901 }
12902 {
12903 if (temp2)
12904 delete arg2;
12905 }
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj = 0;
12912 wxInputStream *arg1 = 0 ;
12913 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12914 int arg3 = (int) -1 ;
12915 wxImage *result = 0 ;
12916 wxPyInputStream *temp1 ;
12917 bool created1 ;
12918 long val2 ;
12919 int ecode2 = 0 ;
12920 int val3 ;
12921 int ecode3 = 0 ;
12922 PyObject * obj0 = 0 ;
12923 PyObject * obj1 = 0 ;
12924 PyObject * obj2 = 0 ;
12925 char * kwnames[] = {
12926 (char *) "stream",(char *) "type",(char *) "index", NULL
12927 };
12928
12929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12930 {
12931 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12932 arg1 = temp1->m_wxis;
12933 created1 = false;
12934 } else {
12935 PyErr_Clear(); // clear the failure of the wxPyConvert above
12936 arg1 = wxPyCBInputStream_create(obj0, false);
12937 if (arg1 == NULL) {
12938 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12939 SWIG_fail;
12940 }
12941 created1 = true;
12942 }
12943 }
12944 if (obj1) {
12945 ecode2 = SWIG_AsVal_long(obj1, &val2);
12946 if (!SWIG_IsOK(ecode2)) {
12947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12948 }
12949 arg2 = static_cast< long >(val2);
12950 }
12951 if (obj2) {
12952 ecode3 = SWIG_AsVal_int(obj2, &val3);
12953 if (!SWIG_IsOK(ecode3)) {
12954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12955 }
12956 arg3 = static_cast< int >(val3);
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12965 {
12966 if (created1) delete arg1;
12967 }
12968 return resultobj;
12969 fail:
12970 {
12971 if (created1) delete arg1;
12972 }
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12978 PyObject *resultobj = 0;
12979 wxInputStream *arg1 = 0 ;
12980 wxString *arg2 = 0 ;
12981 int arg3 = (int) -1 ;
12982 wxImage *result = 0 ;
12983 wxPyInputStream *temp1 ;
12984 bool created1 ;
12985 bool temp2 = false ;
12986 int val3 ;
12987 int ecode3 = 0 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 char * kwnames[] = {
12992 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12993 };
12994
12995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12996 {
12997 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12998 arg1 = temp1->m_wxis;
12999 created1 = false;
13000 } else {
13001 PyErr_Clear(); // clear the failure of the wxPyConvert above
13002 arg1 = wxPyCBInputStream_create(obj0, false);
13003 if (arg1 == NULL) {
13004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13005 SWIG_fail;
13006 }
13007 created1 = true;
13008 }
13009 }
13010 {
13011 arg2 = wxString_in_helper(obj1);
13012 if (arg2 == NULL) SWIG_fail;
13013 temp2 = true;
13014 }
13015 if (obj2) {
13016 ecode3 = SWIG_AsVal_int(obj2, &val3);
13017 if (!SWIG_IsOK(ecode3)) {
13018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13019 }
13020 arg3 = static_cast< int >(val3);
13021 }
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13029 {
13030 if (created1) delete arg1;
13031 }
13032 {
13033 if (temp2)
13034 delete arg2;
13035 }
13036 return resultobj;
13037 fail:
13038 {
13039 if (created1) delete arg1;
13040 }
13041 {
13042 if (temp2)
13043 delete arg2;
13044 }
13045 return NULL;
13046 }
13047
13048
13049 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj = 0;
13051 int arg1 = (int) 0 ;
13052 int arg2 = (int) 0 ;
13053 bool arg3 = (bool) true ;
13054 wxImage *result = 0 ;
13055 int val1 ;
13056 int ecode1 = 0 ;
13057 int val2 ;
13058 int ecode2 = 0 ;
13059 bool val3 ;
13060 int ecode3 = 0 ;
13061 PyObject * obj0 = 0 ;
13062 PyObject * obj1 = 0 ;
13063 PyObject * obj2 = 0 ;
13064 char * kwnames[] = {
13065 (char *) "width",(char *) "height",(char *) "clear", NULL
13066 };
13067
13068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13069 if (obj0) {
13070 ecode1 = SWIG_AsVal_int(obj0, &val1);
13071 if (!SWIG_IsOK(ecode1)) {
13072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13073 }
13074 arg1 = static_cast< int >(val1);
13075 }
13076 if (obj1) {
13077 ecode2 = SWIG_AsVal_int(obj1, &val2);
13078 if (!SWIG_IsOK(ecode2)) {
13079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13080 }
13081 arg2 = static_cast< int >(val2);
13082 }
13083 if (obj2) {
13084 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13085 if (!SWIG_IsOK(ecode3)) {
13086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13087 }
13088 arg3 = static_cast< bool >(val3);
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13097 return resultobj;
13098 fail:
13099 return NULL;
13100 }
13101
13102
13103 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj = 0;
13105 wxBitmap *arg1 = 0 ;
13106 wxImage *result = 0 ;
13107 void *argp1 = 0 ;
13108 int res1 = 0 ;
13109 PyObject * obj0 = 0 ;
13110 char * kwnames[] = {
13111 (char *) "bitmap", NULL
13112 };
13113
13114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13115 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13116 if (!SWIG_IsOK(res1)) {
13117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13118 }
13119 if (!argp1) {
13120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13121 }
13122 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13123 {
13124 if (!wxPyCheckForApp()) SWIG_fail;
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj = 0;
13139 int arg1 ;
13140 int arg2 ;
13141 buffer arg3 ;
13142 int arg4 ;
13143 wxImage *result = 0 ;
13144 int val1 ;
13145 int ecode1 = 0 ;
13146 int val2 ;
13147 int ecode2 = 0 ;
13148 PyObject * obj0 = 0 ;
13149 PyObject * obj1 = 0 ;
13150 PyObject * obj2 = 0 ;
13151 char * kwnames[] = {
13152 (char *) "width",(char *) "height",(char *) "data", NULL
13153 };
13154
13155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13156 ecode1 = SWIG_AsVal_int(obj0, &val1);
13157 if (!SWIG_IsOK(ecode1)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13159 }
13160 arg1 = static_cast< int >(val1);
13161 ecode2 = SWIG_AsVal_int(obj1, &val2);
13162 if (!SWIG_IsOK(ecode2)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13164 }
13165 arg2 = static_cast< int >(val2);
13166 {
13167 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 int arg1 ;
13185 int arg2 ;
13186 buffer arg3 ;
13187 int arg4 ;
13188 buffer arg5 ;
13189 int arg6 ;
13190 wxImage *result = 0 ;
13191 int val1 ;
13192 int ecode1 = 0 ;
13193 int val2 ;
13194 int ecode2 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 PyObject * obj2 = 0 ;
13198 PyObject * obj3 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13204 ecode1 = SWIG_AsVal_int(obj0, &val1);
13205 if (!SWIG_IsOK(ecode1)) {
13206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13207 }
13208 arg1 = static_cast< int >(val1);
13209 ecode2 = SWIG_AsVal_int(obj1, &val2);
13210 if (!SWIG_IsOK(ecode2)) {
13211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13212 }
13213 arg2 = static_cast< int >(val2);
13214 {
13215 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13216 }
13217 {
13218 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13219 }
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 wxImage *arg1 = (wxImage *) 0 ;
13236 int arg2 ;
13237 int arg3 ;
13238 bool arg4 = (bool) true ;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 int val2 ;
13242 int ecode2 = 0 ;
13243 int val3 ;
13244 int ecode3 = 0 ;
13245 bool val4 ;
13246 int ecode4 = 0 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 PyObject * obj2 = 0 ;
13250 PyObject * obj3 = 0 ;
13251 char * kwnames[] = {
13252 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13253 };
13254
13255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13257 if (!SWIG_IsOK(res1)) {
13258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13259 }
13260 arg1 = reinterpret_cast< wxImage * >(argp1);
13261 ecode2 = SWIG_AsVal_int(obj1, &val2);
13262 if (!SWIG_IsOK(ecode2)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13264 }
13265 arg2 = static_cast< int >(val2);
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 if (obj3) {
13272 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13273 if (!SWIG_IsOK(ecode4)) {
13274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13275 }
13276 arg4 = static_cast< bool >(val4);
13277 }
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 (arg1)->Create(arg2,arg3,arg4);
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 resultobj = SWIG_Py_Void();
13285 return resultobj;
13286 fail:
13287 return NULL;
13288 }
13289
13290
13291 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13292 PyObject *resultobj = 0;
13293 wxImage *arg1 = (wxImage *) 0 ;
13294 void *argp1 = 0 ;
13295 int res1 = 0 ;
13296 PyObject *swig_obj[1] ;
13297
13298 if (!args) SWIG_fail;
13299 swig_obj[0] = args;
13300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13303 }
13304 arg1 = reinterpret_cast< wxImage * >(argp1);
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 (arg1)->Destroy();
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_Py_Void();
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj = 0;
13320 wxImage *arg1 = (wxImage *) 0 ;
13321 int arg2 ;
13322 int arg3 ;
13323 SwigValueWrapper<wxImage > result;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 int val2 ;
13327 int ecode2 = 0 ;
13328 int val3 ;
13329 int ecode3 = 0 ;
13330 PyObject * obj0 = 0 ;
13331 PyObject * obj1 = 0 ;
13332 PyObject * obj2 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "self",(char *) "width",(char *) "height", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13339 if (!SWIG_IsOK(res1)) {
13340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13341 }
13342 arg1 = reinterpret_cast< wxImage * >(argp1);
13343 ecode2 = SWIG_AsVal_int(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13346 }
13347 arg2 = static_cast< int >(val2);
13348 ecode3 = SWIG_AsVal_int(obj2, &val3);
13349 if (!SWIG_IsOK(ecode3)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13351 }
13352 arg3 = static_cast< int >(val3);
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = (arg1)->Scale(arg2,arg3);
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj = 0;
13368 wxImage *arg1 = (wxImage *) 0 ;
13369 int arg2 ;
13370 int arg3 ;
13371 SwigValueWrapper<wxImage > result;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 int val2 ;
13375 int ecode2 = 0 ;
13376 int val3 ;
13377 int ecode3 = 0 ;
13378 PyObject * obj0 = 0 ;
13379 PyObject * obj1 = 0 ;
13380 PyObject * obj2 = 0 ;
13381 char * kwnames[] = {
13382 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13383 };
13384
13385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13389 }
13390 arg1 = reinterpret_cast< wxImage * >(argp1);
13391 ecode2 = SWIG_AsVal_int(obj1, &val2);
13392 if (!SWIG_IsOK(ecode2)) {
13393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13394 }
13395 arg2 = static_cast< int >(val2);
13396 ecode3 = SWIG_AsVal_int(obj2, &val3);
13397 if (!SWIG_IsOK(ecode3)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13399 }
13400 arg3 = static_cast< int >(val3);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj = 0;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 int arg2 ;
13418 int arg3 ;
13419 wxImage *result = 0 ;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 int val2 ;
13423 int ecode2 = 0 ;
13424 int val3 ;
13425 int ecode3 = 0 ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 PyObject * obj2 = 0 ;
13429 char * kwnames[] = {
13430 (char *) "self",(char *) "width",(char *) "height", NULL
13431 };
13432
13433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13435 if (!SWIG_IsOK(res1)) {
13436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13437 }
13438 arg1 = reinterpret_cast< wxImage * >(argp1);
13439 ecode2 = SWIG_AsVal_int(obj1, &val2);
13440 if (!SWIG_IsOK(ecode2)) {
13441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13442 }
13443 arg2 = static_cast< int >(val2);
13444 ecode3 = SWIG_AsVal_int(obj2, &val3);
13445 if (!SWIG_IsOK(ecode3)) {
13446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13447 }
13448 arg3 = static_cast< int >(val3);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 {
13452 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13453 result = (wxImage *) &_result_ref;
13454 }
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13466 PyObject *resultobj = 0;
13467 wxImage *arg1 = (wxImage *) 0 ;
13468 wxSize *arg2 = 0 ;
13469 wxPoint *arg3 = 0 ;
13470 int arg4 = (int) -1 ;
13471 int arg5 = (int) -1 ;
13472 int arg6 = (int) -1 ;
13473 wxImage *result = 0 ;
13474 void *argp1 = 0 ;
13475 int res1 = 0 ;
13476 wxSize temp2 ;
13477 wxPoint temp3 ;
13478 int val4 ;
13479 int ecode4 = 0 ;
13480 int val5 ;
13481 int ecode5 = 0 ;
13482 int val6 ;
13483 int ecode6 = 0 ;
13484 PyObject * obj0 = 0 ;
13485 PyObject * obj1 = 0 ;
13486 PyObject * obj2 = 0 ;
13487 PyObject * obj3 = 0 ;
13488 PyObject * obj4 = 0 ;
13489 PyObject * obj5 = 0 ;
13490 char * kwnames[] = {
13491 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13492 };
13493
13494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13496 if (!SWIG_IsOK(res1)) {
13497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13498 }
13499 arg1 = reinterpret_cast< wxImage * >(argp1);
13500 {
13501 arg2 = &temp2;
13502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13503 }
13504 {
13505 arg3 = &temp3;
13506 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13507 }
13508 if (obj3) {
13509 ecode4 = SWIG_AsVal_int(obj3, &val4);
13510 if (!SWIG_IsOK(ecode4)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13512 }
13513 arg4 = static_cast< int >(val4);
13514 }
13515 if (obj4) {
13516 ecode5 = SWIG_AsVal_int(obj4, &val5);
13517 if (!SWIG_IsOK(ecode5)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13519 }
13520 arg5 = static_cast< int >(val5);
13521 }
13522 if (obj5) {
13523 ecode6 = SWIG_AsVal_int(obj5, &val6);
13524 if (!SWIG_IsOK(ecode6)) {
13525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13526 }
13527 arg6 = static_cast< int >(val6);
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 {
13532 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13533 result = (wxImage *) &_result_ref;
13534 }
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 wxImage *arg1 = (wxImage *) 0 ;
13548 int arg2 ;
13549 int arg3 ;
13550 byte arg4 ;
13551 byte arg5 ;
13552 byte arg6 ;
13553 void *argp1 = 0 ;
13554 int res1 = 0 ;
13555 int val2 ;
13556 int ecode2 = 0 ;
13557 int val3 ;
13558 int ecode3 = 0 ;
13559 unsigned char val4 ;
13560 int ecode4 = 0 ;
13561 unsigned char val5 ;
13562 int ecode5 = 0 ;
13563 unsigned char val6 ;
13564 int ecode6 = 0 ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 PyObject * obj2 = 0 ;
13568 PyObject * obj3 = 0 ;
13569 PyObject * obj4 = 0 ;
13570 PyObject * obj5 = 0 ;
13571 char * kwnames[] = {
13572 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13573 };
13574
13575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13577 if (!SWIG_IsOK(res1)) {
13578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13579 }
13580 arg1 = reinterpret_cast< wxImage * >(argp1);
13581 ecode2 = SWIG_AsVal_int(obj1, &val2);
13582 if (!SWIG_IsOK(ecode2)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13584 }
13585 arg2 = static_cast< int >(val2);
13586 ecode3 = SWIG_AsVal_int(obj2, &val3);
13587 if (!SWIG_IsOK(ecode3)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13589 }
13590 arg3 = static_cast< int >(val3);
13591 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13592 if (!SWIG_IsOK(ecode4)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13594 }
13595 arg4 = static_cast< byte >(val4);
13596 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13597 if (!SWIG_IsOK(ecode5)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13599 }
13600 arg5 = static_cast< byte >(val5);
13601 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13602 if (!SWIG_IsOK(ecode6)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13604 }
13605 arg6 = static_cast< byte >(val6);
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_Py_Void();
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxImage *arg1 = (wxImage *) 0 ;
13622 wxRect *arg2 = 0 ;
13623 byte arg3 ;
13624 byte arg4 ;
13625 byte arg5 ;
13626 void *argp1 = 0 ;
13627 int res1 = 0 ;
13628 wxRect temp2 ;
13629 unsigned char val3 ;
13630 int ecode3 = 0 ;
13631 unsigned char val4 ;
13632 int ecode4 = 0 ;
13633 unsigned char val5 ;
13634 int ecode5 = 0 ;
13635 PyObject * obj0 = 0 ;
13636 PyObject * obj1 = 0 ;
13637 PyObject * obj2 = 0 ;
13638 PyObject * obj3 = 0 ;
13639 PyObject * obj4 = 0 ;
13640 char * kwnames[] = {
13641 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13642 };
13643
13644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13646 if (!SWIG_IsOK(res1)) {
13647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13648 }
13649 arg1 = reinterpret_cast< wxImage * >(argp1);
13650 {
13651 arg2 = &temp2;
13652 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13653 }
13654 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13655 if (!SWIG_IsOK(ecode3)) {
13656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13657 }
13658 arg3 = static_cast< byte >(val3);
13659 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13660 if (!SWIG_IsOK(ecode4)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13662 }
13663 arg4 = static_cast< byte >(val4);
13664 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13665 if (!SWIG_IsOK(ecode5)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13667 }
13668 arg5 = static_cast< byte >(val5);
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_Py_Void();
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxImage *arg1 = (wxImage *) 0 ;
13685 int arg2 ;
13686 int arg3 ;
13687 byte result;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 int val3 ;
13693 int ecode3 = 0 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "x",(char *) "y", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 ecode3 = SWIG_AsVal_int(obj2, &val3);
13713 if (!SWIG_IsOK(ecode3)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13715 }
13716 arg3 = static_cast< int >(val3);
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = (byte)(arg1)->GetRed(arg2,arg3);
13720 wxPyEndAllowThreads(__tstate);
13721 if (PyErr_Occurred()) SWIG_fail;
13722 }
13723 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj = 0;
13732 wxImage *arg1 = (wxImage *) 0 ;
13733 int arg2 ;
13734 int arg3 ;
13735 byte result;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 int val2 ;
13739 int ecode2 = 0 ;
13740 int val3 ;
13741 int ecode3 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 PyObject * obj2 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "self",(char *) "x",(char *) "y", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13753 }
13754 arg1 = reinterpret_cast< wxImage * >(argp1);
13755 ecode2 = SWIG_AsVal_int(obj1, &val2);
13756 if (!SWIG_IsOK(ecode2)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13758 }
13759 arg2 = static_cast< int >(val2);
13760 ecode3 = SWIG_AsVal_int(obj2, &val3);
13761 if (!SWIG_IsOK(ecode3)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13763 }
13764 arg3 = static_cast< int >(val3);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (byte)(arg1)->GetGreen(arg2,arg3);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 int arg2 ;
13782 int arg3 ;
13783 byte result;
13784 void *argp1 = 0 ;
13785 int res1 = 0 ;
13786 int val2 ;
13787 int ecode2 = 0 ;
13788 int val3 ;
13789 int ecode3 = 0 ;
13790 PyObject * obj0 = 0 ;
13791 PyObject * obj1 = 0 ;
13792 PyObject * obj2 = 0 ;
13793 char * kwnames[] = {
13794 (char *) "self",(char *) "x",(char *) "y", NULL
13795 };
13796
13797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13799 if (!SWIG_IsOK(res1)) {
13800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13801 }
13802 arg1 = reinterpret_cast< wxImage * >(argp1);
13803 ecode2 = SWIG_AsVal_int(obj1, &val2);
13804 if (!SWIG_IsOK(ecode2)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13806 }
13807 arg2 = static_cast< int >(val2);
13808 ecode3 = SWIG_AsVal_int(obj2, &val3);
13809 if (!SWIG_IsOK(ecode3)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13811 }
13812 arg3 = static_cast< int >(val3);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (byte)(arg1)->GetBlue(arg2,arg3);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte arg4 ;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 unsigned char val4 ;
13839 int ecode4 = 0 ;
13840 PyObject * obj0 = 0 ;
13841 PyObject * obj1 = 0 ;
13842 PyObject * obj2 = 0 ;
13843 PyObject * obj3 = 0 ;
13844 char * kwnames[] = {
13845 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13846 };
13847
13848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13850 if (!SWIG_IsOK(res1)) {
13851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13852 }
13853 arg1 = reinterpret_cast< wxImage * >(argp1);
13854 ecode2 = SWIG_AsVal_int(obj1, &val2);
13855 if (!SWIG_IsOK(ecode2)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13857 }
13858 arg2 = static_cast< int >(val2);
13859 ecode3 = SWIG_AsVal_int(obj2, &val3);
13860 if (!SWIG_IsOK(ecode3)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13862 }
13863 arg3 = static_cast< int >(val3);
13864 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13865 if (!SWIG_IsOK(ecode4)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13867 }
13868 arg4 = static_cast< byte >(val4);
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 (arg1)->SetAlpha(arg2,arg3,arg4);
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 resultobj = SWIG_Py_Void();
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = 0;
13884 wxImage *arg1 = (wxImage *) 0 ;
13885 int arg2 ;
13886 int arg3 ;
13887 byte result;
13888 void *argp1 = 0 ;
13889 int res1 = 0 ;
13890 int val2 ;
13891 int ecode2 = 0 ;
13892 int val3 ;
13893 int ecode3 = 0 ;
13894 PyObject * obj0 = 0 ;
13895 PyObject * obj1 = 0 ;
13896 PyObject * obj2 = 0 ;
13897 char * kwnames[] = {
13898 (char *) "self",(char *) "x",(char *) "y", NULL
13899 };
13900
13901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13903 if (!SWIG_IsOK(res1)) {
13904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13905 }
13906 arg1 = reinterpret_cast< wxImage * >(argp1);
13907 ecode2 = SWIG_AsVal_int(obj1, &val2);
13908 if (!SWIG_IsOK(ecode2)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13910 }
13911 arg2 = static_cast< int >(val2);
13912 ecode3 = SWIG_AsVal_int(obj2, &val3);
13913 if (!SWIG_IsOK(ecode3)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13915 }
13916 arg3 = static_cast< int >(val3);
13917 {
13918 PyThreadState* __tstate = wxPyBeginAllowThreads();
13919 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13920 wxPyEndAllowThreads(__tstate);
13921 if (PyErr_Occurred()) SWIG_fail;
13922 }
13923 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13931 PyObject *resultobj = 0;
13932 wxImage *arg1 = (wxImage *) 0 ;
13933 bool result;
13934 void *argp1 = 0 ;
13935 int res1 = 0 ;
13936 PyObject *swig_obj[1] ;
13937
13938 if (!args) SWIG_fail;
13939 swig_obj[0] = args;
13940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13943 }
13944 arg1 = reinterpret_cast< wxImage * >(argp1);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (bool)(arg1)->HasAlpha();
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 {
13952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13953 }
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13961 PyObject *resultobj = 0;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 void *argp1 = 0 ;
13964 int res1 = 0 ;
13965 PyObject *swig_obj[1] ;
13966
13967 if (!args) SWIG_fail;
13968 swig_obj[0] = args;
13969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13970 if (!SWIG_IsOK(res1)) {
13971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13972 }
13973 arg1 = reinterpret_cast< wxImage * >(argp1);
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 (arg1)->InitAlpha();
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_Py_Void();
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13988 PyObject *resultobj = 0;
13989 wxImage *arg1 = (wxImage *) 0 ;
13990 int arg2 ;
13991 int arg3 ;
13992 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13993 bool result;
13994 void *argp1 = 0 ;
13995 int res1 = 0 ;
13996 int val2 ;
13997 int ecode2 = 0 ;
13998 int val3 ;
13999 int ecode3 = 0 ;
14000 unsigned char val4 ;
14001 int ecode4 = 0 ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 PyObject * obj2 = 0 ;
14005 PyObject * obj3 = 0 ;
14006 char * kwnames[] = {
14007 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14008 };
14009
14010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14012 if (!SWIG_IsOK(res1)) {
14013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14014 }
14015 arg1 = reinterpret_cast< wxImage * >(argp1);
14016 ecode2 = SWIG_AsVal_int(obj1, &val2);
14017 if (!SWIG_IsOK(ecode2)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14019 }
14020 arg2 = static_cast< int >(val2);
14021 ecode3 = SWIG_AsVal_int(obj2, &val3);
14022 if (!SWIG_IsOK(ecode3)) {
14023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14024 }
14025 arg3 = static_cast< int >(val3);
14026 if (obj3) {
14027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14028 if (!SWIG_IsOK(ecode4)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14030 }
14031 arg4 = static_cast< byte >(val4);
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 {
14040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14041 }
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj = 0;
14050 wxImage *arg1 = (wxImage *) 0 ;
14051 byte *arg2 = (byte *) 0 ;
14052 byte *arg3 = (byte *) 0 ;
14053 byte *arg4 = (byte *) 0 ;
14054 byte arg5 = (byte) 0 ;
14055 byte arg6 = (byte) 0 ;
14056 byte arg7 = (byte) 0 ;
14057 bool result;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 byte temp2 ;
14061 int res2 = SWIG_TMPOBJ ;
14062 byte temp3 ;
14063 int res3 = SWIG_TMPOBJ ;
14064 byte temp4 ;
14065 int res4 = SWIG_TMPOBJ ;
14066 unsigned char val5 ;
14067 int ecode5 = 0 ;
14068 unsigned char val6 ;
14069 int ecode6 = 0 ;
14070 unsigned char val7 ;
14071 int ecode7 = 0 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 PyObject * obj3 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14078 };
14079
14080 arg2 = &temp2;
14081 arg3 = &temp3;
14082 arg4 = &temp4;
14083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14085 if (!SWIG_IsOK(res1)) {
14086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14087 }
14088 arg1 = reinterpret_cast< wxImage * >(argp1);
14089 if (obj1) {
14090 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14091 if (!SWIG_IsOK(ecode5)) {
14092 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14093 }
14094 arg5 = static_cast< byte >(val5);
14095 }
14096 if (obj2) {
14097 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14098 if (!SWIG_IsOK(ecode6)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14100 }
14101 arg6 = static_cast< byte >(val6);
14102 }
14103 if (obj3) {
14104 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14105 if (!SWIG_IsOK(ecode7)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14107 }
14108 arg7 = static_cast< byte >(val7);
14109 }
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14118 }
14119 if (SWIG_IsTmpObj(res2)) {
14120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14121 } else {
14122 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14124 }
14125 if (SWIG_IsTmpObj(res3)) {
14126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14127 } else {
14128 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14130 }
14131 if (SWIG_IsTmpObj(res4)) {
14132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14133 } else {
14134 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14136 }
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14147 bool result;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 unsigned char val2 ;
14151 int ecode2 = 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 char * kwnames[] = {
14155 (char *) "self",(char *) "threshold", NULL
14156 };
14157
14158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14160 if (!SWIG_IsOK(res1)) {
14161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14162 }
14163 arg1 = reinterpret_cast< wxImage * >(argp1);
14164 if (obj1) {
14165 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14166 if (!SWIG_IsOK(ecode2)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14168 }
14169 arg2 = static_cast< byte >(val2);
14170 }
14171 {
14172 PyThreadState* __tstate = wxPyBeginAllowThreads();
14173 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 {
14178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14179 }
14180 return resultobj;
14181 fail:
14182 return NULL;
14183 }
14184
14185
14186 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14187 PyObject *resultobj = 0;
14188 wxImage *arg1 = (wxImage *) 0 ;
14189 byte arg2 ;
14190 byte arg3 ;
14191 byte arg4 ;
14192 bool result;
14193 void *argp1 = 0 ;
14194 int res1 = 0 ;
14195 unsigned char val2 ;
14196 int ecode2 = 0 ;
14197 unsigned char val3 ;
14198 int ecode3 = 0 ;
14199 unsigned char val4 ;
14200 int ecode4 = 0 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 PyObject * obj2 = 0 ;
14204 PyObject * obj3 = 0 ;
14205 char * kwnames[] = {
14206 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14207 };
14208
14209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14211 if (!SWIG_IsOK(res1)) {
14212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14213 }
14214 arg1 = reinterpret_cast< wxImage * >(argp1);
14215 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14216 if (!SWIG_IsOK(ecode2)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14218 }
14219 arg2 = static_cast< byte >(val2);
14220 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14221 if (!SWIG_IsOK(ecode3)) {
14222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14223 }
14224 arg3 = static_cast< byte >(val3);
14225 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14226 if (!SWIG_IsOK(ecode4)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14228 }
14229 arg4 = static_cast< byte >(val4);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 {
14237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14238 }
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = 0;
14247 wxImage *arg1 = (wxImage *) 0 ;
14248 wxImage *arg2 = 0 ;
14249 byte arg3 ;
14250 byte arg4 ;
14251 byte arg5 ;
14252 bool result;
14253 void *argp1 = 0 ;
14254 int res1 = 0 ;
14255 void *argp2 = 0 ;
14256 int res2 = 0 ;
14257 unsigned char val3 ;
14258 int ecode3 = 0 ;
14259 unsigned char val4 ;
14260 int ecode4 = 0 ;
14261 unsigned char val5 ;
14262 int ecode5 = 0 ;
14263 PyObject * obj0 = 0 ;
14264 PyObject * obj1 = 0 ;
14265 PyObject * obj2 = 0 ;
14266 PyObject * obj3 = 0 ;
14267 PyObject * obj4 = 0 ;
14268 char * kwnames[] = {
14269 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14270 };
14271
14272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14274 if (!SWIG_IsOK(res1)) {
14275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14276 }
14277 arg1 = reinterpret_cast< wxImage * >(argp1);
14278 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14279 if (!SWIG_IsOK(res2)) {
14280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14281 }
14282 if (!argp2) {
14283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14284 }
14285 arg2 = reinterpret_cast< wxImage * >(argp2);
14286 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14287 if (!SWIG_IsOK(ecode3)) {
14288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14289 }
14290 arg3 = static_cast< byte >(val3);
14291 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14292 if (!SWIG_IsOK(ecode4)) {
14293 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14294 }
14295 arg4 = static_cast< byte >(val4);
14296 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14297 if (!SWIG_IsOK(ecode5)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14299 }
14300 arg5 = static_cast< byte >(val5);
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 {
14308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14309 }
14310 return resultobj;
14311 fail:
14312 return NULL;
14313 }
14314
14315
14316 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj = 0;
14318 wxString *arg1 = 0 ;
14319 bool result;
14320 bool temp1 = false ;
14321 PyObject * obj0 = 0 ;
14322 char * kwnames[] = {
14323 (char *) "filename", NULL
14324 };
14325
14326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14327 {
14328 arg1 = wxString_in_helper(obj0);
14329 if (arg1 == NULL) SWIG_fail;
14330 temp1 = true;
14331 }
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 {
14339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14340 }
14341 {
14342 if (temp1)
14343 delete arg1;
14344 }
14345 return resultobj;
14346 fail:
14347 {
14348 if (temp1)
14349 delete arg1;
14350 }
14351 return NULL;
14352 }
14353
14354
14355 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj = 0;
14357 wxString *arg1 = 0 ;
14358 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14359 int result;
14360 bool temp1 = false ;
14361 long val2 ;
14362 int ecode2 = 0 ;
14363 PyObject * obj0 = 0 ;
14364 PyObject * obj1 = 0 ;
14365 char * kwnames[] = {
14366 (char *) "filename",(char *) "type", NULL
14367 };
14368
14369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14370 {
14371 arg1 = wxString_in_helper(obj0);
14372 if (arg1 == NULL) SWIG_fail;
14373 temp1 = true;
14374 }
14375 if (obj1) {
14376 ecode2 = SWIG_AsVal_long(obj1, &val2);
14377 if (!SWIG_IsOK(ecode2)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14379 }
14380 arg2 = static_cast< long >(val2);
14381 }
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 resultobj = SWIG_From_int(static_cast< int >(result));
14389 {
14390 if (temp1)
14391 delete arg1;
14392 }
14393 return resultobj;
14394 fail:
14395 {
14396 if (temp1)
14397 delete arg1;
14398 }
14399 return NULL;
14400 }
14401
14402
14403 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj = 0;
14405 wxImage *arg1 = (wxImage *) 0 ;
14406 wxString *arg2 = 0 ;
14407 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14408 int arg4 = (int) -1 ;
14409 bool result;
14410 void *argp1 = 0 ;
14411 int res1 = 0 ;
14412 bool temp2 = false ;
14413 long val3 ;
14414 int ecode3 = 0 ;
14415 int val4 ;
14416 int ecode4 = 0 ;
14417 PyObject * obj0 = 0 ;
14418 PyObject * obj1 = 0 ;
14419 PyObject * obj2 = 0 ;
14420 PyObject * obj3 = 0 ;
14421 char * kwnames[] = {
14422 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14423 };
14424
14425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14429 }
14430 arg1 = reinterpret_cast< wxImage * >(argp1);
14431 {
14432 arg2 = wxString_in_helper(obj1);
14433 if (arg2 == NULL) SWIG_fail;
14434 temp2 = true;
14435 }
14436 if (obj2) {
14437 ecode3 = SWIG_AsVal_long(obj2, &val3);
14438 if (!SWIG_IsOK(ecode3)) {
14439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14440 }
14441 arg3 = static_cast< long >(val3);
14442 }
14443 if (obj3) {
14444 ecode4 = SWIG_AsVal_int(obj3, &val4);
14445 if (!SWIG_IsOK(ecode4)) {
14446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14447 }
14448 arg4 = static_cast< int >(val4);
14449 }
14450 {
14451 PyThreadState* __tstate = wxPyBeginAllowThreads();
14452 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 {
14457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14458 }
14459 {
14460 if (temp2)
14461 delete arg2;
14462 }
14463 return resultobj;
14464 fail:
14465 {
14466 if (temp2)
14467 delete arg2;
14468 }
14469 return NULL;
14470 }
14471
14472
14473 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14474 PyObject *resultobj = 0;
14475 wxImage *arg1 = (wxImage *) 0 ;
14476 wxString *arg2 = 0 ;
14477 wxString *arg3 = 0 ;
14478 int arg4 = (int) -1 ;
14479 bool result;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 bool temp2 = false ;
14483 bool temp3 = false ;
14484 int val4 ;
14485 int ecode4 = 0 ;
14486 PyObject * obj0 = 0 ;
14487 PyObject * obj1 = 0 ;
14488 PyObject * obj2 = 0 ;
14489 PyObject * obj3 = 0 ;
14490 char * kwnames[] = {
14491 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14492 };
14493
14494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14496 if (!SWIG_IsOK(res1)) {
14497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14498 }
14499 arg1 = reinterpret_cast< wxImage * >(argp1);
14500 {
14501 arg2 = wxString_in_helper(obj1);
14502 if (arg2 == NULL) SWIG_fail;
14503 temp2 = true;
14504 }
14505 {
14506 arg3 = wxString_in_helper(obj2);
14507 if (arg3 == NULL) SWIG_fail;
14508 temp3 = true;
14509 }
14510 if (obj3) {
14511 ecode4 = SWIG_AsVal_int(obj3, &val4);
14512 if (!SWIG_IsOK(ecode4)) {
14513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14514 }
14515 arg4 = static_cast< int >(val4);
14516 }
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 {
14524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14525 }
14526 {
14527 if (temp2)
14528 delete arg2;
14529 }
14530 {
14531 if (temp3)
14532 delete arg3;
14533 }
14534 return resultobj;
14535 fail:
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 {
14541 if (temp3)
14542 delete arg3;
14543 }
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj = 0;
14550 wxImage *arg1 = (wxImage *) 0 ;
14551 wxString *arg2 = 0 ;
14552 int arg3 ;
14553 bool result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 bool temp2 = false ;
14557 int val3 ;
14558 int ecode3 = 0 ;
14559 PyObject * obj0 = 0 ;
14560 PyObject * obj1 = 0 ;
14561 PyObject * obj2 = 0 ;
14562 char * kwnames[] = {
14563 (char *) "self",(char *) "name",(char *) "type", NULL
14564 };
14565
14566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14568 if (!SWIG_IsOK(res1)) {
14569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14570 }
14571 arg1 = reinterpret_cast< wxImage * >(argp1);
14572 {
14573 arg2 = wxString_in_helper(obj1);
14574 if (arg2 == NULL) SWIG_fail;
14575 temp2 = true;
14576 }
14577 ecode3 = SWIG_AsVal_int(obj2, &val3);
14578 if (!SWIG_IsOK(ecode3)) {
14579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14580 }
14581 arg3 = static_cast< int >(val3);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 {
14589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14590 }
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 return resultobj;
14596 fail:
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj = 0;
14607 wxImage *arg1 = (wxImage *) 0 ;
14608 wxString *arg2 = 0 ;
14609 wxString *arg3 = 0 ;
14610 bool result;
14611 void *argp1 = 0 ;
14612 int res1 = 0 ;
14613 bool temp2 = false ;
14614 bool temp3 = false ;
14615 PyObject * obj0 = 0 ;
14616 PyObject * obj1 = 0 ;
14617 PyObject * obj2 = 0 ;
14618 char * kwnames[] = {
14619 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14620 };
14621
14622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14624 if (!SWIG_IsOK(res1)) {
14625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14626 }
14627 arg1 = reinterpret_cast< wxImage * >(argp1);
14628 {
14629 arg2 = wxString_in_helper(obj1);
14630 if (arg2 == NULL) SWIG_fail;
14631 temp2 = true;
14632 }
14633 {
14634 arg3 = wxString_in_helper(obj2);
14635 if (arg3 == NULL) SWIG_fail;
14636 temp3 = true;
14637 }
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 {
14645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14646 }
14647 {
14648 if (temp2)
14649 delete arg2;
14650 }
14651 {
14652 if (temp3)
14653 delete arg3;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 {
14662 if (temp3)
14663 delete arg3;
14664 }
14665 return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14670 PyObject *resultobj = 0;
14671 wxInputStream *arg1 = 0 ;
14672 bool result;
14673 wxPyInputStream *temp1 ;
14674 bool created1 ;
14675 PyObject * obj0 = 0 ;
14676 char * kwnames[] = {
14677 (char *) "stream", NULL
14678 };
14679
14680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14681 {
14682 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14683 arg1 = temp1->m_wxis;
14684 created1 = false;
14685 } else {
14686 PyErr_Clear(); // clear the failure of the wxPyConvert above
14687 arg1 = wxPyCBInputStream_create(obj0, false);
14688 if (arg1 == NULL) {
14689 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14690 SWIG_fail;
14691 }
14692 created1 = true;
14693 }
14694 }
14695 {
14696 PyThreadState* __tstate = wxPyBeginAllowThreads();
14697 result = (bool)wxImage::CanRead(*arg1);
14698 wxPyEndAllowThreads(__tstate);
14699 if (PyErr_Occurred()) SWIG_fail;
14700 }
14701 {
14702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14703 }
14704 {
14705 if (created1) delete arg1;
14706 }
14707 return resultobj;
14708 fail:
14709 {
14710 if (created1) delete arg1;
14711 }
14712 return NULL;
14713 }
14714
14715
14716 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14717 PyObject *resultobj = 0;
14718 wxImage *arg1 = (wxImage *) 0 ;
14719 wxInputStream *arg2 = 0 ;
14720 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14721 int arg4 = (int) -1 ;
14722 bool result;
14723 void *argp1 = 0 ;
14724 int res1 = 0 ;
14725 wxPyInputStream *temp2 ;
14726 bool created2 ;
14727 long val3 ;
14728 int ecode3 = 0 ;
14729 int val4 ;
14730 int ecode4 = 0 ;
14731 PyObject * obj0 = 0 ;
14732 PyObject * obj1 = 0 ;
14733 PyObject * obj2 = 0 ;
14734 PyObject * obj3 = 0 ;
14735 char * kwnames[] = {
14736 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14737 };
14738
14739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14743 }
14744 arg1 = reinterpret_cast< wxImage * >(argp1);
14745 {
14746 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14747 arg2 = temp2->m_wxis;
14748 created2 = false;
14749 } else {
14750 PyErr_Clear(); // clear the failure of the wxPyConvert above
14751 arg2 = wxPyCBInputStream_create(obj1, false);
14752 if (arg2 == NULL) {
14753 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14754 SWIG_fail;
14755 }
14756 created2 = true;
14757 }
14758 }
14759 if (obj2) {
14760 ecode3 = SWIG_AsVal_long(obj2, &val3);
14761 if (!SWIG_IsOK(ecode3)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14763 }
14764 arg3 = static_cast< long >(val3);
14765 }
14766 if (obj3) {
14767 ecode4 = SWIG_AsVal_int(obj3, &val4);
14768 if (!SWIG_IsOK(ecode4)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14770 }
14771 arg4 = static_cast< int >(val4);
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (created2) delete arg2;
14784 }
14785 return resultobj;
14786 fail:
14787 {
14788 if (created2) delete arg2;
14789 }
14790 return NULL;
14791 }
14792
14793
14794 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj = 0;
14796 wxImage *arg1 = (wxImage *) 0 ;
14797 wxInputStream *arg2 = 0 ;
14798 wxString *arg3 = 0 ;
14799 int arg4 = (int) -1 ;
14800 bool result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 wxPyInputStream *temp2 ;
14804 bool created2 ;
14805 bool temp3 = false ;
14806 int val4 ;
14807 int ecode4 = 0 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 PyObject * obj2 = 0 ;
14811 PyObject * obj3 = 0 ;
14812 char * kwnames[] = {
14813 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14814 };
14815
14816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14818 if (!SWIG_IsOK(res1)) {
14819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14820 }
14821 arg1 = reinterpret_cast< wxImage * >(argp1);
14822 {
14823 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14824 arg2 = temp2->m_wxis;
14825 created2 = false;
14826 } else {
14827 PyErr_Clear(); // clear the failure of the wxPyConvert above
14828 arg2 = wxPyCBInputStream_create(obj1, false);
14829 if (arg2 == NULL) {
14830 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14831 SWIG_fail;
14832 }
14833 created2 = true;
14834 }
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_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14845 }
14846 arg4 = static_cast< int >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)(arg1)->LoadFile(*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 (created2) delete arg2;
14859 }
14860 {
14861 if (temp3)
14862 delete arg3;
14863 }
14864 return resultobj;
14865 fail:
14866 {
14867 if (created2) delete arg2;
14868 }
14869 {
14870 if (temp3)
14871 delete arg3;
14872 }
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14878 PyObject *resultobj = 0;
14879 wxImage *arg1 = (wxImage *) 0 ;
14880 bool result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 PyObject *swig_obj[1] ;
14884
14885 if (!args) SWIG_fail;
14886 swig_obj[0] = args;
14887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14888 if (!SWIG_IsOK(res1)) {
14889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14890 }
14891 arg1 = reinterpret_cast< wxImage * >(argp1);
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (bool)(arg1)->Ok();
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 {
14899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14900 }
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14908 PyObject *resultobj = 0;
14909 wxImage *arg1 = (wxImage *) 0 ;
14910 int result;
14911 void *argp1 = 0 ;
14912 int res1 = 0 ;
14913 PyObject *swig_obj[1] ;
14914
14915 if (!args) SWIG_fail;
14916 swig_obj[0] = args;
14917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14918 if (!SWIG_IsOK(res1)) {
14919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14920 }
14921 arg1 = reinterpret_cast< wxImage * >(argp1);
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = (int)(arg1)->GetWidth();
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 resultobj = SWIG_From_int(static_cast< int >(result));
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14936 PyObject *resultobj = 0;
14937 wxImage *arg1 = (wxImage *) 0 ;
14938 int result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 PyObject *swig_obj[1] ;
14942
14943 if (!args) SWIG_fail;
14944 swig_obj[0] = args;
14945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14946 if (!SWIG_IsOK(res1)) {
14947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14948 }
14949 arg1 = reinterpret_cast< wxImage * >(argp1);
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (int)(arg1)->GetHeight();
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 resultobj = SWIG_From_int(static_cast< int >(result));
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxImage *arg1 = (wxImage *) 0 ;
14966 wxSize result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14976 }
14977 arg1 = reinterpret_cast< wxImage * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = wxImage_GetSize(arg1);
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14985 return resultobj;
14986 fail:
14987 return NULL;
14988 }
14989
14990
14991 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14992 PyObject *resultobj = 0;
14993 wxImage *arg1 = (wxImage *) 0 ;
14994 wxRect *arg2 = 0 ;
14995 SwigValueWrapper<wxImage > result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 wxRect temp2 ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 char * kwnames[] = {
15002 (char *) "self",(char *) "rect", NULL
15003 };
15004
15005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15007 if (!SWIG_IsOK(res1)) {
15008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15009 }
15010 arg1 = reinterpret_cast< wxImage * >(argp1);
15011 {
15012 arg2 = &temp2;
15013 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15014 }
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxImage *arg1 = (wxImage *) 0 ;
15031 wxSize *arg2 = 0 ;
15032 wxPoint *arg3 = 0 ;
15033 int arg4 = (int) -1 ;
15034 int arg5 = (int) -1 ;
15035 int arg6 = (int) -1 ;
15036 SwigValueWrapper<wxImage > result;
15037 void *argp1 = 0 ;
15038 int res1 = 0 ;
15039 wxSize temp2 ;
15040 wxPoint temp3 ;
15041 int val4 ;
15042 int ecode4 = 0 ;
15043 int val5 ;
15044 int ecode5 = 0 ;
15045 int val6 ;
15046 int ecode6 = 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 PyObject * obj2 = 0 ;
15050 PyObject * obj3 = 0 ;
15051 PyObject * obj4 = 0 ;
15052 PyObject * obj5 = 0 ;
15053 char * kwnames[] = {
15054 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15055 };
15056
15057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15059 if (!SWIG_IsOK(res1)) {
15060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15061 }
15062 arg1 = reinterpret_cast< wxImage * >(argp1);
15063 {
15064 arg2 = &temp2;
15065 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15066 }
15067 {
15068 arg3 = &temp3;
15069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15070 }
15071 if (obj3) {
15072 ecode4 = SWIG_AsVal_int(obj3, &val4);
15073 if (!SWIG_IsOK(ecode4)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15075 }
15076 arg4 = static_cast< int >(val4);
15077 }
15078 if (obj4) {
15079 ecode5 = SWIG_AsVal_int(obj4, &val5);
15080 if (!SWIG_IsOK(ecode5)) {
15081 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15082 }
15083 arg5 = static_cast< int >(val5);
15084 }
15085 if (obj5) {
15086 ecode6 = SWIG_AsVal_int(obj5, &val6);
15087 if (!SWIG_IsOK(ecode6)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15089 }
15090 arg6 = static_cast< int >(val6);
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 PyObject *resultobj = 0;
15107 wxImage *arg1 = (wxImage *) 0 ;
15108 SwigValueWrapper<wxImage > result;
15109 void *argp1 = 0 ;
15110 int res1 = 0 ;
15111 PyObject *swig_obj[1] ;
15112
15113 if (!args) SWIG_fail;
15114 swig_obj[0] = args;
15115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15116 if (!SWIG_IsOK(res1)) {
15117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15118 }
15119 arg1 = reinterpret_cast< wxImage * >(argp1);
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (arg1)->Copy();
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj = 0;
15135 wxImage *arg1 = (wxImage *) 0 ;
15136 wxImage *arg2 = 0 ;
15137 int arg3 ;
15138 int arg4 ;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 void *argp2 = 0 ;
15142 int res2 = 0 ;
15143 int val3 ;
15144 int ecode3 = 0 ;
15145 int val4 ;
15146 int ecode4 = 0 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 PyObject * obj2 = 0 ;
15150 PyObject * obj3 = 0 ;
15151 char * kwnames[] = {
15152 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15153 };
15154
15155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15159 }
15160 arg1 = reinterpret_cast< wxImage * >(argp1);
15161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15162 if (!SWIG_IsOK(res2)) {
15163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15164 }
15165 if (!argp2) {
15166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15167 }
15168 arg2 = reinterpret_cast< wxImage * >(argp2);
15169 ecode3 = SWIG_AsVal_int(obj2, &val3);
15170 if (!SWIG_IsOK(ecode3)) {
15171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15172 }
15173 arg3 = static_cast< int >(val3);
15174 ecode4 = SWIG_AsVal_int(obj3, &val4);
15175 if (!SWIG_IsOK(ecode4)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15177 }
15178 arg4 = static_cast< int >(val4);
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 resultobj = SWIG_Py_Void();
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxImage *arg1 = (wxImage *) 0 ;
15195 PyObject *result = 0 ;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage * >(argp1);
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (PyObject *)wxImage_GetData(arg1);
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = result;
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 buffer arg2 ;
15224 int arg3 ;
15225 void *argp1 = 0 ;
15226 int res1 = 0 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 char * kwnames[] = {
15230 (char *) "self",(char *) "data", NULL
15231 };
15232
15233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15237 }
15238 arg1 = reinterpret_cast< wxImage * >(argp1);
15239 {
15240 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15241 }
15242 {
15243 PyThreadState* __tstate = wxPyBeginAllowThreads();
15244 wxImage_SetData(arg1,arg2,arg3);
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 resultobj = SWIG_Py_Void();
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15256 PyObject *resultobj = 0;
15257 wxImage *arg1 = (wxImage *) 0 ;
15258 PyObject *result = 0 ;
15259 void *argp1 = 0 ;
15260 int res1 = 0 ;
15261 PyObject *swig_obj[1] ;
15262
15263 if (!args) SWIG_fail;
15264 swig_obj[0] = args;
15265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15268 }
15269 arg1 = reinterpret_cast< wxImage * >(argp1);
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15273 wxPyEndAllowThreads(__tstate);
15274 if (PyErr_Occurred()) SWIG_fail;
15275 }
15276 resultobj = result;
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15284 PyObject *resultobj = 0;
15285 wxImage *arg1 = (wxImage *) 0 ;
15286 buffer arg2 ;
15287 int arg3 ;
15288 void *argp1 = 0 ;
15289 int res1 = 0 ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "data", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 wxImage_SetDataBuffer(arg1,arg2,arg3);
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = SWIG_Py_Void();
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15319 PyObject *resultobj = 0;
15320 wxImage *arg1 = (wxImage *) 0 ;
15321 PyObject *result = 0 ;
15322 void *argp1 = 0 ;
15323 int res1 = 0 ;
15324 PyObject *swig_obj[1] ;
15325
15326 if (!args) SWIG_fail;
15327 swig_obj[0] = args;
15328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15331 }
15332 arg1 = reinterpret_cast< wxImage * >(argp1);
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (PyObject *)wxImage_GetAlphaData(arg1);
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 resultobj = result;
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj = 0;
15348 wxImage *arg1 = (wxImage *) 0 ;
15349 buffer arg2 ;
15350 int arg3 ;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 char * kwnames[] = {
15356 (char *) "self",(char *) "alpha", NULL
15357 };
15358
15359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage * >(argp1);
15365 {
15366 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15367 }
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 wxImage_SetAlphaData(arg1,arg2,arg3);
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_Py_Void();
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxImage *arg1 = (wxImage *) 0 ;
15384 PyObject *result = 0 ;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject *swig_obj[1] ;
15388
15389 if (!args) SWIG_fail;
15390 swig_obj[0] = args;
15391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15394 }
15395 arg1 = reinterpret_cast< wxImage * >(argp1);
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = result;
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = 0;
15411 wxImage *arg1 = (wxImage *) 0 ;
15412 buffer arg2 ;
15413 int arg3 ;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "self",(char *) "alpha", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 {
15429 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15430 }
15431 {
15432 PyThreadState* __tstate = wxPyBeginAllowThreads();
15433 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 resultobj = SWIG_Py_Void();
15438 return resultobj;
15439 fail:
15440 return NULL;
15441 }
15442
15443
15444 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15445 PyObject *resultobj = 0;
15446 wxImage *arg1 = (wxImage *) 0 ;
15447 byte arg2 ;
15448 byte arg3 ;
15449 byte arg4 ;
15450 void *argp1 = 0 ;
15451 int res1 = 0 ;
15452 unsigned char val2 ;
15453 int ecode2 = 0 ;
15454 unsigned char val3 ;
15455 int ecode3 = 0 ;
15456 unsigned char val4 ;
15457 int ecode4 = 0 ;
15458 PyObject * obj0 = 0 ;
15459 PyObject * obj1 = 0 ;
15460 PyObject * obj2 = 0 ;
15461 PyObject * obj3 = 0 ;
15462 char * kwnames[] = {
15463 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15464 };
15465
15466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15468 if (!SWIG_IsOK(res1)) {
15469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15470 }
15471 arg1 = reinterpret_cast< wxImage * >(argp1);
15472 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15473 if (!SWIG_IsOK(ecode2)) {
15474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15475 }
15476 arg2 = static_cast< byte >(val2);
15477 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15478 if (!SWIG_IsOK(ecode3)) {
15479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15480 }
15481 arg3 = static_cast< byte >(val3);
15482 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15483 if (!SWIG_IsOK(ecode4)) {
15484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15485 }
15486 arg4 = static_cast< byte >(val4);
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 (arg1)->SetMaskColour(arg2,arg3,arg4);
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 resultobj = SWIG_Py_Void();
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15501 PyObject *resultobj = 0;
15502 wxImage *arg1 = (wxImage *) 0 ;
15503 byte *arg2 = (byte *) 0 ;
15504 byte *arg3 = (byte *) 0 ;
15505 byte *arg4 = (byte *) 0 ;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 byte temp2 ;
15509 int res2 = SWIG_TMPOBJ ;
15510 byte temp3 ;
15511 int res3 = SWIG_TMPOBJ ;
15512 byte temp4 ;
15513 int res4 = SWIG_TMPOBJ ;
15514 PyObject *swig_obj[1] ;
15515
15516 arg2 = &temp2;
15517 arg3 = &temp3;
15518 arg4 = &temp4;
15519 if (!args) SWIG_fail;
15520 swig_obj[0] = args;
15521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15522 if (!SWIG_IsOK(res1)) {
15523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15524 }
15525 arg1 = reinterpret_cast< wxImage * >(argp1);
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 resultobj = SWIG_Py_Void();
15533 if (SWIG_IsTmpObj(res2)) {
15534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15535 } else {
15536 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15538 }
15539 if (SWIG_IsTmpObj(res3)) {
15540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15541 } else {
15542 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15544 }
15545 if (SWIG_IsTmpObj(res4)) {
15546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15547 } else {
15548 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15550 }
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15558 PyObject *resultobj = 0;
15559 wxImage *arg1 = (wxImage *) 0 ;
15560 byte result;
15561 void *argp1 = 0 ;
15562 int res1 = 0 ;
15563 PyObject *swig_obj[1] ;
15564
15565 if (!args) SWIG_fail;
15566 swig_obj[0] = args;
15567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 result = (byte)(arg1)->GetMaskRed();
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15586 PyObject *resultobj = 0;
15587 wxImage *arg1 = (wxImage *) 0 ;
15588 byte result;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 PyObject *swig_obj[1] ;
15592
15593 if (!args) SWIG_fail;
15594 swig_obj[0] = args;
15595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15598 }
15599 arg1 = reinterpret_cast< wxImage * >(argp1);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (byte)(arg1)->GetMaskGreen();
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15614 PyObject *resultobj = 0;
15615 wxImage *arg1 = (wxImage *) 0 ;
15616 byte result;
15617 void *argp1 = 0 ;
15618 int res1 = 0 ;
15619 PyObject *swig_obj[1] ;
15620
15621 if (!args) SWIG_fail;
15622 swig_obj[0] = args;
15623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15626 }
15627 arg1 = reinterpret_cast< wxImage * >(argp1);
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (byte)(arg1)->GetMaskBlue();
15631 wxPyEndAllowThreads(__tstate);
15632 if (PyErr_Occurred()) SWIG_fail;
15633 }
15634 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15635 return resultobj;
15636 fail:
15637 return NULL;
15638 }
15639
15640
15641 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15642 PyObject *resultobj = 0;
15643 wxImage *arg1 = (wxImage *) 0 ;
15644 bool arg2 = (bool) true ;
15645 void *argp1 = 0 ;
15646 int res1 = 0 ;
15647 bool val2 ;
15648 int ecode2 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char * kwnames[] = {
15652 (char *) "self",(char *) "mask", NULL
15653 };
15654
15655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15657 if (!SWIG_IsOK(res1)) {
15658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15659 }
15660 arg1 = reinterpret_cast< wxImage * >(argp1);
15661 if (obj1) {
15662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15663 if (!SWIG_IsOK(ecode2)) {
15664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15665 }
15666 arg2 = static_cast< bool >(val2);
15667 }
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 (arg1)->SetMask(arg2);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_Py_Void();
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 bool result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15694 }
15695 arg1 = reinterpret_cast< wxImage * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (bool)(arg1)->HasMask();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 {
15703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj = 0;
15713 wxImage *arg1 = (wxImage *) 0 ;
15714 double arg2 ;
15715 wxPoint *arg3 = 0 ;
15716 bool arg4 = (bool) true ;
15717 wxPoint *arg5 = (wxPoint *) NULL ;
15718 SwigValueWrapper<wxImage > result;
15719 void *argp1 = 0 ;
15720 int res1 = 0 ;
15721 double val2 ;
15722 int ecode2 = 0 ;
15723 wxPoint temp3 ;
15724 bool val4 ;
15725 int ecode4 = 0 ;
15726 void *argp5 = 0 ;
15727 int res5 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 PyObject * obj2 = 0 ;
15731 PyObject * obj3 = 0 ;
15732 PyObject * obj4 = 0 ;
15733 char * kwnames[] = {
15734 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15735 };
15736
15737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15739 if (!SWIG_IsOK(res1)) {
15740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15741 }
15742 arg1 = reinterpret_cast< wxImage * >(argp1);
15743 ecode2 = SWIG_AsVal_double(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15746 }
15747 arg2 = static_cast< double >(val2);
15748 {
15749 arg3 = &temp3;
15750 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15751 }
15752 if (obj3) {
15753 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15754 if (!SWIG_IsOK(ecode4)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15756 }
15757 arg4 = static_cast< bool >(val4);
15758 }
15759 if (obj4) {
15760 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15761 if (!SWIG_IsOK(res5)) {
15762 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15763 }
15764 arg5 = reinterpret_cast< wxPoint * >(argp5);
15765 }
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15780 PyObject *resultobj = 0;
15781 wxImage *arg1 = (wxImage *) 0 ;
15782 bool arg2 = (bool) true ;
15783 SwigValueWrapper<wxImage > result;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 bool val2 ;
15787 int ecode2 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "self",(char *) "clockwise", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15798 }
15799 arg1 = reinterpret_cast< wxImage * >(argp1);
15800 if (obj1) {
15801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15802 if (!SWIG_IsOK(ecode2)) {
15803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15804 }
15805 arg2 = static_cast< bool >(val2);
15806 }
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (arg1)->Rotate90(arg2);
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj = 0;
15822 wxImage *arg1 = (wxImage *) 0 ;
15823 bool arg2 = (bool) true ;
15824 SwigValueWrapper<wxImage > result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 bool val2 ;
15828 int ecode2 = 0 ;
15829 PyObject * obj0 = 0 ;
15830 PyObject * obj1 = 0 ;
15831 char * kwnames[] = {
15832 (char *) "self",(char *) "horizontally", NULL
15833 };
15834
15835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15837 if (!SWIG_IsOK(res1)) {
15838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15839 }
15840 arg1 = reinterpret_cast< wxImage * >(argp1);
15841 if (obj1) {
15842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15843 if (!SWIG_IsOK(ecode2)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15845 }
15846 arg2 = static_cast< bool >(val2);
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 result = (arg1)->Mirror(arg2);
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15855 return resultobj;
15856 fail:
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj = 0;
15863 wxImage *arg1 = (wxImage *) 0 ;
15864 byte arg2 ;
15865 byte arg3 ;
15866 byte arg4 ;
15867 byte arg5 ;
15868 byte arg6 ;
15869 byte arg7 ;
15870 void *argp1 = 0 ;
15871 int res1 = 0 ;
15872 unsigned char val2 ;
15873 int ecode2 = 0 ;
15874 unsigned char val3 ;
15875 int ecode3 = 0 ;
15876 unsigned char val4 ;
15877 int ecode4 = 0 ;
15878 unsigned char val5 ;
15879 int ecode5 = 0 ;
15880 unsigned char val6 ;
15881 int ecode6 = 0 ;
15882 unsigned char val7 ;
15883 int ecode7 = 0 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 PyObject * obj2 = 0 ;
15887 PyObject * obj3 = 0 ;
15888 PyObject * obj4 = 0 ;
15889 PyObject * obj5 = 0 ;
15890 PyObject * obj6 = 0 ;
15891 char * kwnames[] = {
15892 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15893 };
15894
15895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15899 }
15900 arg1 = reinterpret_cast< wxImage * >(argp1);
15901 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15902 if (!SWIG_IsOK(ecode2)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15904 }
15905 arg2 = static_cast< byte >(val2);
15906 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15907 if (!SWIG_IsOK(ecode3)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15909 }
15910 arg3 = static_cast< byte >(val3);
15911 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15912 if (!SWIG_IsOK(ecode4)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15914 }
15915 arg4 = static_cast< byte >(val4);
15916 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15917 if (!SWIG_IsOK(ecode5)) {
15918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15919 }
15920 arg5 = static_cast< byte >(val5);
15921 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15922 if (!SWIG_IsOK(ecode6)) {
15923 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15924 }
15925 arg6 = static_cast< byte >(val6);
15926 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15927 if (!SWIG_IsOK(ecode7)) {
15928 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15929 }
15930 arg7 = static_cast< byte >(val7);
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 resultobj = SWIG_Py_Void();
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15945 PyObject *resultobj = 0;
15946 wxImage *arg1 = (wxImage *) 0 ;
15947 double arg2 = (double) 0.299 ;
15948 double arg3 = (double) 0.587 ;
15949 double arg4 = (double) 0.114 ;
15950 SwigValueWrapper<wxImage > result;
15951 void *argp1 = 0 ;
15952 int res1 = 0 ;
15953 double val2 ;
15954 int ecode2 = 0 ;
15955 double val3 ;
15956 int ecode3 = 0 ;
15957 double val4 ;
15958 int ecode4 = 0 ;
15959 PyObject * obj0 = 0 ;
15960 PyObject * obj1 = 0 ;
15961 PyObject * obj2 = 0 ;
15962 PyObject * obj3 = 0 ;
15963 char * kwnames[] = {
15964 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15965 };
15966
15967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15969 if (!SWIG_IsOK(res1)) {
15970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15971 }
15972 arg1 = reinterpret_cast< wxImage * >(argp1);
15973 if (obj1) {
15974 ecode2 = SWIG_AsVal_double(obj1, &val2);
15975 if (!SWIG_IsOK(ecode2)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15977 }
15978 arg2 = static_cast< double >(val2);
15979 }
15980 if (obj2) {
15981 ecode3 = SWIG_AsVal_double(obj2, &val3);
15982 if (!SWIG_IsOK(ecode3)) {
15983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15984 }
15985 arg3 = static_cast< double >(val3);
15986 }
15987 if (obj3) {
15988 ecode4 = SWIG_AsVal_double(obj3, &val4);
15989 if (!SWIG_IsOK(ecode4)) {
15990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15991 }
15992 arg4 = static_cast< double >(val4);
15993 }
15994 {
15995 PyThreadState* __tstate = wxPyBeginAllowThreads();
15996 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15997 wxPyEndAllowThreads(__tstate);
15998 if (PyErr_Occurred()) SWIG_fail;
15999 }
16000 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj = 0;
16009 wxImage *arg1 = (wxImage *) 0 ;
16010 byte arg2 ;
16011 byte arg3 ;
16012 byte arg4 ;
16013 SwigValueWrapper<wxImage > result;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 unsigned char val2 ;
16017 int ecode2 = 0 ;
16018 unsigned char val3 ;
16019 int ecode3 = 0 ;
16020 unsigned char val4 ;
16021 int ecode4 = 0 ;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 PyObject * obj2 = 0 ;
16025 PyObject * obj3 = 0 ;
16026 char * kwnames[] = {
16027 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16028 };
16029
16030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16034 }
16035 arg1 = reinterpret_cast< wxImage * >(argp1);
16036 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16037 if (!SWIG_IsOK(ecode2)) {
16038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16039 }
16040 arg2 = static_cast< byte >(val2);
16041 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16042 if (!SWIG_IsOK(ecode3)) {
16043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16044 }
16045 arg3 = static_cast< byte >(val3);
16046 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16047 if (!SWIG_IsOK(ecode4)) {
16048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16049 }
16050 arg4 = static_cast< byte >(val4);
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj = 0;
16066 wxImage *arg1 = (wxImage *) 0 ;
16067 wxString *arg2 = 0 ;
16068 wxString *arg3 = 0 ;
16069 void *argp1 = 0 ;
16070 int res1 = 0 ;
16071 bool temp2 = false ;
16072 bool temp3 = false ;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 PyObject * obj2 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "name",(char *) "value", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) 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_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 {
16087 arg2 = wxString_in_helper(obj1);
16088 if (arg2 == NULL) SWIG_fail;
16089 temp2 = true;
16090 }
16091 {
16092 arg3 = wxString_in_helper(obj2);
16093 if (arg3 == NULL) SWIG_fail;
16094 temp3 = true;
16095 }
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_Py_Void();
16103 {
16104 if (temp2)
16105 delete arg2;
16106 }
16107 {
16108 if (temp3)
16109 delete arg3;
16110 }
16111 return resultobj;
16112 fail:
16113 {
16114 if (temp2)
16115 delete arg2;
16116 }
16117 {
16118 if (temp3)
16119 delete arg3;
16120 }
16121 return NULL;
16122 }
16123
16124
16125 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj = 0;
16127 wxImage *arg1 = (wxImage *) 0 ;
16128 wxString *arg2 = 0 ;
16129 int arg3 ;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 bool temp2 = false ;
16133 int val3 ;
16134 int ecode3 = 0 ;
16135 PyObject * obj0 = 0 ;
16136 PyObject * obj1 = 0 ;
16137 PyObject * obj2 = 0 ;
16138 char * kwnames[] = {
16139 (char *) "self",(char *) "name",(char *) "value", NULL
16140 };
16141
16142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16144 if (!SWIG_IsOK(res1)) {
16145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16146 }
16147 arg1 = reinterpret_cast< wxImage * >(argp1);
16148 {
16149 arg2 = wxString_in_helper(obj1);
16150 if (arg2 == NULL) SWIG_fail;
16151 temp2 = true;
16152 }
16153 ecode3 = SWIG_AsVal_int(obj2, &val3);
16154 if (!SWIG_IsOK(ecode3)) {
16155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16156 }
16157 arg3 = static_cast< int >(val3);
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 (arg1)->SetOption((wxString const &)*arg2,arg3);
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 resultobj = SWIG_Py_Void();
16165 {
16166 if (temp2)
16167 delete arg2;
16168 }
16169 return resultobj;
16170 fail:
16171 {
16172 if (temp2)
16173 delete arg2;
16174 }
16175 return NULL;
16176 }
16177
16178
16179 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj = 0;
16181 wxImage *arg1 = (wxImage *) 0 ;
16182 wxString *arg2 = 0 ;
16183 wxString result;
16184 void *argp1 = 0 ;
16185 int res1 = 0 ;
16186 bool temp2 = false ;
16187 PyObject * obj0 = 0 ;
16188 PyObject * obj1 = 0 ;
16189 char * kwnames[] = {
16190 (char *) "self",(char *) "name", NULL
16191 };
16192
16193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16197 }
16198 arg1 = reinterpret_cast< wxImage * >(argp1);
16199 {
16200 arg2 = wxString_in_helper(obj1);
16201 if (arg2 == NULL) SWIG_fail;
16202 temp2 = true;
16203 }
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 {
16211 #if wxUSE_UNICODE
16212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16213 #else
16214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16215 #endif
16216 }
16217 {
16218 if (temp2)
16219 delete arg2;
16220 }
16221 return resultobj;
16222 fail:
16223 {
16224 if (temp2)
16225 delete arg2;
16226 }
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 wxString *arg2 = 0 ;
16235 int result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 bool temp2 = false ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 char * kwnames[] = {
16242 (char *) "self",(char *) "name", NULL
16243 };
16244
16245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16247 if (!SWIG_IsOK(res1)) {
16248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16249 }
16250 arg1 = reinterpret_cast< wxImage * >(argp1);
16251 {
16252 arg2 = wxString_in_helper(obj1);
16253 if (arg2 == NULL) SWIG_fail;
16254 temp2 = true;
16255 }
16256 {
16257 PyThreadState* __tstate = wxPyBeginAllowThreads();
16258 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 resultobj = SWIG_From_int(static_cast< int >(result));
16263 {
16264 if (temp2)
16265 delete arg2;
16266 }
16267 return resultobj;
16268 fail:
16269 {
16270 if (temp2)
16271 delete arg2;
16272 }
16273 return NULL;
16274 }
16275
16276
16277 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj = 0;
16279 wxImage *arg1 = (wxImage *) 0 ;
16280 wxString *arg2 = 0 ;
16281 bool result;
16282 void *argp1 = 0 ;
16283 int res1 = 0 ;
16284 bool temp2 = false ;
16285 PyObject * obj0 = 0 ;
16286 PyObject * obj1 = 0 ;
16287 char * kwnames[] = {
16288 (char *) "self",(char *) "name", NULL
16289 };
16290
16291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16293 if (!SWIG_IsOK(res1)) {
16294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16295 }
16296 arg1 = reinterpret_cast< wxImage * >(argp1);
16297 {
16298 arg2 = wxString_in_helper(obj1);
16299 if (arg2 == NULL) SWIG_fail;
16300 temp2 = true;
16301 }
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16310 }
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 return resultobj;
16316 fail:
16317 {
16318 if (temp2)
16319 delete arg2;
16320 }
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16329 unsigned long result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 unsigned long val2 ;
16333 int ecode2 = 0 ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "stopafter", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16344 }
16345 arg1 = reinterpret_cast< wxImage * >(argp1);
16346 if (obj1) {
16347 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16348 if (!SWIG_IsOK(ecode2)) {
16349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16350 }
16351 arg2 = static_cast< unsigned long >(val2);
16352 }
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (unsigned long)(arg1)->CountColours(arg2);
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj = 0;
16368 wxImage *arg1 = (wxImage *) 0 ;
16369 wxImageHistogram *arg2 = 0 ;
16370 unsigned long result;
16371 void *argp1 = 0 ;
16372 int res1 = 0 ;
16373 void *argp2 = 0 ;
16374 int res2 = 0 ;
16375 PyObject * obj0 = 0 ;
16376 PyObject * obj1 = 0 ;
16377 char * kwnames[] = {
16378 (char *) "self",(char *) "h", NULL
16379 };
16380
16381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16383 if (!SWIG_IsOK(res1)) {
16384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16385 }
16386 arg1 = reinterpret_cast< wxImage * >(argp1);
16387 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16388 if (!SWIG_IsOK(res2)) {
16389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16390 }
16391 if (!argp2) {
16392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16393 }
16394 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj = 0;
16410 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16411 void *argp1 = 0 ;
16412 int res1 = 0 ;
16413 PyObject * obj0 = 0 ;
16414 char * kwnames[] = {
16415 (char *) "handler", NULL
16416 };
16417
16418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16420 if (!SWIG_IsOK(res1)) {
16421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16422 }
16423 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 wxImage::AddHandler(arg1);
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 resultobj = SWIG_Py_Void();
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16440 void *argp1 = 0 ;
16441 int res1 = 0 ;
16442 PyObject * obj0 = 0 ;
16443 char * kwnames[] = {
16444 (char *) "handler", NULL
16445 };
16446
16447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16449 if (!SWIG_IsOK(res1)) {
16450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16451 }
16452 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16453 {
16454 PyThreadState* __tstate = wxPyBeginAllowThreads();
16455 wxImage::InsertHandler(arg1);
16456 wxPyEndAllowThreads(__tstate);
16457 if (PyErr_Occurred()) SWIG_fail;
16458 }
16459 resultobj = SWIG_Py_Void();
16460 return resultobj;
16461 fail:
16462 return NULL;
16463 }
16464
16465
16466 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj = 0;
16468 wxString *arg1 = 0 ;
16469 bool result;
16470 bool temp1 = false ;
16471 PyObject * obj0 = 0 ;
16472 char * kwnames[] = {
16473 (char *) "name", NULL
16474 };
16475
16476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16477 {
16478 arg1 = wxString_in_helper(obj0);
16479 if (arg1 == NULL) SWIG_fail;
16480 temp1 = true;
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 {
16489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16490 }
16491 {
16492 if (temp1)
16493 delete arg1;
16494 }
16495 return resultobj;
16496 fail:
16497 {
16498 if (temp1)
16499 delete arg1;
16500 }
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16506 PyObject *resultobj = 0;
16507 PyObject *result = 0 ;
16508
16509 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (PyObject *)wxImage_GetHandlers();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 resultobj = result;
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16524 PyObject *resultobj = 0;
16525 wxString result;
16526
16527 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 result = wxImage::GetImageExtWildcard();
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 #if wxUSE_UNICODE
16536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16537 #else
16538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16539 #endif
16540 }
16541 return resultobj;
16542 fail:
16543 return NULL;
16544 }
16545
16546
16547 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj = 0;
16549 wxImage *arg1 = (wxImage *) 0 ;
16550 int arg2 = (int) -1 ;
16551 wxBitmap result;
16552 void *argp1 = 0 ;
16553 int res1 = 0 ;
16554 int val2 ;
16555 int ecode2 = 0 ;
16556 PyObject * obj0 = 0 ;
16557 PyObject * obj1 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "self",(char *) "depth", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16566 }
16567 arg1 = reinterpret_cast< wxImage * >(argp1);
16568 if (obj1) {
16569 ecode2 = SWIG_AsVal_int(obj1, &val2);
16570 if (!SWIG_IsOK(ecode2)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16572 }
16573 arg2 = static_cast< int >(val2);
16574 }
16575 {
16576 if (!wxPyCheckForApp()) SWIG_fail;
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = wxImage_ConvertToBitmap(arg1,arg2);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 byte arg2 ;
16593 byte arg3 ;
16594 byte arg4 ;
16595 wxBitmap result;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 unsigned char val2 ;
16599 int ecode2 = 0 ;
16600 unsigned char val3 ;
16601 int ecode3 = 0 ;
16602 unsigned char val4 ;
16603 int ecode4 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 PyObject * obj2 = 0 ;
16607 PyObject * obj3 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16616 }
16617 arg1 = reinterpret_cast< wxImage * >(argp1);
16618 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16619 if (!SWIG_IsOK(ecode2)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16621 }
16622 arg2 = static_cast< byte >(val2);
16623 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16626 }
16627 arg3 = static_cast< byte >(val3);
16628 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16629 if (!SWIG_IsOK(ecode4)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16631 }
16632 arg4 = static_cast< byte >(val4);
16633 {
16634 if (!wxPyCheckForApp()) SWIG_fail;
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxImage *arg1 = (wxImage *) 0 ;
16650 double arg2 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 double val2 ;
16654 int ecode2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "angle", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16665 }
16666 arg1 = reinterpret_cast< wxImage * >(argp1);
16667 ecode2 = SWIG_AsVal_double(obj1, &val2);
16668 if (!SWIG_IsOK(ecode2)) {
16669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16670 }
16671 arg2 = static_cast< double >(val2);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 (arg1)->RotateHue(arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_Py_Void();
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj = 0;
16687 wxImage_RGBValue arg1 ;
16688 wxImage_HSVValue result;
16689 void *argp1 ;
16690 int res1 = 0 ;
16691 PyObject * obj0 = 0 ;
16692 char * kwnames[] = {
16693 (char *) "rgb", NULL
16694 };
16695
16696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16697 {
16698 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16699 if (!SWIG_IsOK(res1)) {
16700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16701 }
16702 if (!argp1) {
16703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16704 } else {
16705 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16706 arg1 = *temp;
16707 if (SWIG_IsNewObj(res1)) delete temp;
16708 }
16709 }
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = wxImage::RGBtoHSV(arg1);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxImage_HSVValue arg1 ;
16726 wxImage_RGBValue result;
16727 void *argp1 ;
16728 int res1 = 0 ;
16729 PyObject * obj0 = 0 ;
16730 char * kwnames[] = {
16731 (char *) "hsv", NULL
16732 };
16733
16734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16735 {
16736 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16739 }
16740 if (!argp1) {
16741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16742 } else {
16743 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16744 arg1 = *temp;
16745 if (SWIG_IsNewObj(res1)) delete temp;
16746 }
16747 }
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 result = wxImage::HSVtoRGB(arg1);
16751 wxPyEndAllowThreads(__tstate);
16752 if (PyErr_Occurred()) SWIG_fail;
16753 }
16754 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16755 return resultobj;
16756 fail:
16757 return NULL;
16758 }
16759
16760
16761 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16762 PyObject *obj;
16763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16764 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16765 return SWIG_Py_Void();
16766 }
16767
16768 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16769 return SWIG_Python_InitShadowInstance(args);
16770 }
16771
16772 SWIGINTERN int NullImage_set(PyObject *) {
16773 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16774 return 1;
16775 }
16776
16777
16778 SWIGINTERN PyObject *NullImage_get(void) {
16779 PyObject *pyobj = 0;
16780
16781 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16782 return pyobj;
16783 }
16784
16785
16786 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16787 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16788 return 1;
16789 }
16790
16791
16792 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16793 PyObject *pyobj = 0;
16794
16795 {
16796 #if wxUSE_UNICODE
16797 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16798 #else
16799 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16800 #endif
16801 }
16802 return pyobj;
16803 }
16804
16805
16806 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16807 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16808 return 1;
16809 }
16810
16811
16812 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16813 PyObject *pyobj = 0;
16814
16815 {
16816 #if wxUSE_UNICODE
16817 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16818 #else
16819 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16820 #endif
16821 }
16822 return pyobj;
16823 }
16824
16825
16826 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16827 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16828 return 1;
16829 }
16830
16831
16832 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16833 PyObject *pyobj = 0;
16834
16835 {
16836 #if wxUSE_UNICODE
16837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16838 #else
16839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16840 #endif
16841 }
16842 return pyobj;
16843 }
16844
16845
16846 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16847 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16848 return 1;
16849 }
16850
16851
16852 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16853 PyObject *pyobj = 0;
16854
16855 {
16856 #if wxUSE_UNICODE
16857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16858 #else
16859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16860 #endif
16861 }
16862 return pyobj;
16863 }
16864
16865
16866 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16867 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16868 return 1;
16869 }
16870
16871
16872 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16873 PyObject *pyobj = 0;
16874
16875 {
16876 #if wxUSE_UNICODE
16877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16878 #else
16879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16880 #endif
16881 }
16882 return pyobj;
16883 }
16884
16885
16886 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16888 return 1;
16889 }
16890
16891
16892 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16893 PyObject *pyobj = 0;
16894
16895 {
16896 #if wxUSE_UNICODE
16897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16898 #else
16899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16900 #endif
16901 }
16902 return pyobj;
16903 }
16904
16905
16906 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16908 return 1;
16909 }
16910
16911
16912 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16913 PyObject *pyobj = 0;
16914
16915 {
16916 #if wxUSE_UNICODE
16917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16918 #else
16919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16920 #endif
16921 }
16922 return pyobj;
16923 }
16924
16925
16926 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16928 return 1;
16929 }
16930
16931
16932 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16933 PyObject *pyobj = 0;
16934
16935 {
16936 #if wxUSE_UNICODE
16937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16938 #else
16939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16940 #endif
16941 }
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17087 PyObject *resultobj = 0;
17088 wxBMPHandler *result = 0 ;
17089
17090 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = (wxBMPHandler *)new wxBMPHandler();
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *BMPHandler_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_wxBMPHandler, SWIG_NewClientData(obj));
17108 return SWIG_Py_Void();
17109 }
17110
17111 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17112 return SWIG_Python_InitShadowInstance(args);
17113 }
17114
17115 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17116 PyObject *resultobj = 0;
17117 wxICOHandler *result = 0 ;
17118
17119 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17120 {
17121 PyThreadState* __tstate = wxPyBeginAllowThreads();
17122 result = (wxICOHandler *)new wxICOHandler();
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17127 return resultobj;
17128 fail:
17129 return NULL;
17130 }
17131
17132
17133 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17134 PyObject *obj;
17135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17136 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17137 return SWIG_Py_Void();
17138 }
17139
17140 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17141 return SWIG_Python_InitShadowInstance(args);
17142 }
17143
17144 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 PyObject *resultobj = 0;
17146 wxCURHandler *result = 0 ;
17147
17148 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (wxCURHandler *)new wxCURHandler();
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17156 return resultobj;
17157 fail:
17158 return NULL;
17159 }
17160
17161
17162 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17163 PyObject *obj;
17164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17165 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17166 return SWIG_Py_Void();
17167 }
17168
17169 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17170 return SWIG_Python_InitShadowInstance(args);
17171 }
17172
17173 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17174 PyObject *resultobj = 0;
17175 wxANIHandler *result = 0 ;
17176
17177 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (wxANIHandler *)new wxANIHandler();
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17185 return resultobj;
17186 fail:
17187 return NULL;
17188 }
17189
17190
17191 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17192 PyObject *obj;
17193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17194 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17195 return SWIG_Py_Void();
17196 }
17197
17198 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17199 return SWIG_Python_InitShadowInstance(args);
17200 }
17201
17202 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17203 PyObject *resultobj = 0;
17204 wxPNGHandler *result = 0 ;
17205
17206 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (wxPNGHandler *)new wxPNGHandler();
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17221 PyObject *obj;
17222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17223 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17224 return SWIG_Py_Void();
17225 }
17226
17227 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17228 return SWIG_Python_InitShadowInstance(args);
17229 }
17230
17231 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17232 PyObject *resultobj = 0;
17233 wxGIFHandler *result = 0 ;
17234
17235 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17236 {
17237 PyThreadState* __tstate = wxPyBeginAllowThreads();
17238 result = (wxGIFHandler *)new wxGIFHandler();
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17250 PyObject *obj;
17251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17252 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17253 return SWIG_Py_Void();
17254 }
17255
17256 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17257 return SWIG_Python_InitShadowInstance(args);
17258 }
17259
17260 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17261 PyObject *resultobj = 0;
17262 wxPCXHandler *result = 0 ;
17263
17264 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 result = (wxPCXHandler *)new wxPCXHandler();
17268 wxPyEndAllowThreads(__tstate);
17269 if (PyErr_Occurred()) SWIG_fail;
17270 }
17271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17272 return resultobj;
17273 fail:
17274 return NULL;
17275 }
17276
17277
17278 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 PyObject *obj;
17280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17282 return SWIG_Py_Void();
17283 }
17284
17285 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17286 return SWIG_Python_InitShadowInstance(args);
17287 }
17288
17289 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17290 PyObject *resultobj = 0;
17291 wxJPEGHandler *result = 0 ;
17292
17293 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (wxJPEGHandler *)new wxJPEGHandler();
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 PyObject *obj;
17309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17310 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17311 return SWIG_Py_Void();
17312 }
17313
17314 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17315 return SWIG_Python_InitShadowInstance(args);
17316 }
17317
17318 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 PyObject *resultobj = 0;
17320 wxPNMHandler *result = 0 ;
17321
17322 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (wxPNMHandler *)new wxPNMHandler();
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *obj;
17338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17339 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17340 return SWIG_Py_Void();
17341 }
17342
17343 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17344 return SWIG_Python_InitShadowInstance(args);
17345 }
17346
17347 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *resultobj = 0;
17349 wxXPMHandler *result = 0 ;
17350
17351 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (wxXPMHandler *)new wxXPMHandler();
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17359 return resultobj;
17360 fail:
17361 return NULL;
17362 }
17363
17364
17365 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 PyObject *obj;
17367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17368 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17369 return SWIG_Py_Void();
17370 }
17371
17372 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17373 return SWIG_Python_InitShadowInstance(args);
17374 }
17375
17376 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 PyObject *resultobj = 0;
17378 wxTIFFHandler *result = 0 ;
17379
17380 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = (wxTIFFHandler *)new wxTIFFHandler();
17384 wxPyEndAllowThreads(__tstate);
17385 if (PyErr_Occurred()) SWIG_fail;
17386 }
17387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17395 PyObject *obj;
17396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17397 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17398 return SWIG_Py_Void();
17399 }
17400
17401 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17402 return SWIG_Python_InitShadowInstance(args);
17403 }
17404
17405 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17406 PyObject *resultobj = 0;
17407 wxImage *arg1 = 0 ;
17408 wxImage *arg2 = 0 ;
17409 int arg3 = (int) 236 ;
17410 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17411 bool result;
17412 void *argp1 = 0 ;
17413 int res1 = 0 ;
17414 void *argp2 = 0 ;
17415 int res2 = 0 ;
17416 int val3 ;
17417 int ecode3 = 0 ;
17418 int val4 ;
17419 int ecode4 = 0 ;
17420 PyObject * obj0 = 0 ;
17421 PyObject * obj1 = 0 ;
17422 PyObject * obj2 = 0 ;
17423 PyObject * obj3 = 0 ;
17424 char * kwnames[] = {
17425 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17426 };
17427
17428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17429 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17430 if (!SWIG_IsOK(res1)) {
17431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17432 }
17433 if (!argp1) {
17434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17435 }
17436 arg1 = reinterpret_cast< wxImage * >(argp1);
17437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17438 if (!SWIG_IsOK(res2)) {
17439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17440 }
17441 if (!argp2) {
17442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17443 }
17444 arg2 = reinterpret_cast< wxImage * >(argp2);
17445 if (obj2) {
17446 ecode3 = SWIG_AsVal_int(obj2, &val3);
17447 if (!SWIG_IsOK(ecode3)) {
17448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17449 }
17450 arg3 = static_cast< int >(val3);
17451 }
17452 if (obj3) {
17453 ecode4 = SWIG_AsVal_int(obj3, &val4);
17454 if (!SWIG_IsOK(ecode4)) {
17455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17456 }
17457 arg4 = static_cast< int >(val4);
17458 }
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 {
17466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17467 }
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *obj;
17476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17477 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17478 return SWIG_Py_Void();
17479 }
17480
17481 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17482 PyObject *resultobj = 0;
17483 wxEvtHandler *result = 0 ;
17484
17485 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (wxEvtHandler *)new wxEvtHandler();
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 PyObject *resultobj = 0;
17501 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17502 wxEvtHandler *result = 0 ;
17503 void *argp1 = 0 ;
17504 int res1 = 0 ;
17505 PyObject *swig_obj[1] ;
17506
17507 if (!args) SWIG_fail;
17508 swig_obj[0] = args;
17509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17510 if (!SWIG_IsOK(res1)) {
17511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17512 }
17513 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 {
17521 resultobj = wxPyMake_wxObject(result, 0);
17522 }
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 PyObject *resultobj = 0;
17531 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17532 wxEvtHandler *result = 0 ;
17533 void *argp1 = 0 ;
17534 int res1 = 0 ;
17535 PyObject *swig_obj[1] ;
17536
17537 if (!args) SWIG_fail;
17538 swig_obj[0] = args;
17539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17540 if (!SWIG_IsOK(res1)) {
17541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17542 }
17543 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 {
17551 resultobj = wxPyMake_wxObject(result, 0);
17552 }
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17563 void *argp1 = 0 ;
17564 int res1 = 0 ;
17565 void *argp2 = 0 ;
17566 int res2 = 0 ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "self",(char *) "handler", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17577 }
17578 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17580 if (!SWIG_IsOK(res2)) {
17581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17582 }
17583 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 (arg1)->SetNextHandler(arg2);
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 resultobj = SWIG_Py_Void();
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = 0;
17599 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17601 void *argp1 = 0 ;
17602 int res1 = 0 ;
17603 void *argp2 = 0 ;
17604 int res2 = 0 ;
17605 PyObject * obj0 = 0 ;
17606 PyObject * obj1 = 0 ;
17607 char * kwnames[] = {
17608 (char *) "self",(char *) "handler", NULL
17609 };
17610
17611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17613 if (!SWIG_IsOK(res1)) {
17614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17615 }
17616 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17618 if (!SWIG_IsOK(res2)) {
17619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17620 }
17621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 (arg1)->SetPreviousHandler(arg2);
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 resultobj = SWIG_Py_Void();
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17638 bool result;
17639 void *argp1 = 0 ;
17640 int res1 = 0 ;
17641 PyObject *swig_obj[1] ;
17642
17643 if (!args) SWIG_fail;
17644 swig_obj[0] = args;
17645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17646 if (!SWIG_IsOK(res1)) {
17647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17648 }
17649 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)(arg1)->GetEvtHandlerEnabled();
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 {
17657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17658 }
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj = 0;
17667 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17668 bool arg2 ;
17669 void *argp1 = 0 ;
17670 int res1 = 0 ;
17671 bool val2 ;
17672 int ecode2 = 0 ;
17673 PyObject * obj0 = 0 ;
17674 PyObject * obj1 = 0 ;
17675 char * kwnames[] = {
17676 (char *) "self",(char *) "enabled", NULL
17677 };
17678
17679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17681 if (!SWIG_IsOK(res1)) {
17682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17683 }
17684 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17686 if (!SWIG_IsOK(ecode2)) {
17687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17688 }
17689 arg2 = static_cast< bool >(val2);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 (arg1)->SetEvtHandlerEnabled(arg2);
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 resultobj = SWIG_Py_Void();
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj = 0;
17705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17706 wxEvent *arg2 = 0 ;
17707 bool result;
17708 void *argp1 = 0 ;
17709 int res1 = 0 ;
17710 void *argp2 = 0 ;
17711 int res2 = 0 ;
17712 PyObject * obj0 = 0 ;
17713 PyObject * obj1 = 0 ;
17714 char * kwnames[] = {
17715 (char *) "self",(char *) "event", NULL
17716 };
17717
17718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17720 if (!SWIG_IsOK(res1)) {
17721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17722 }
17723 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17725 if (!SWIG_IsOK(res2)) {
17726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17727 }
17728 if (!argp2) {
17729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17730 }
17731 arg2 = reinterpret_cast< wxEvent * >(argp2);
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (bool)(arg1)->ProcessEvent(*arg2);
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 {
17739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17740 }
17741 return resultobj;
17742 fail:
17743 return NULL;
17744 }
17745
17746
17747 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17748 PyObject *resultobj = 0;
17749 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17750 wxEvent *arg2 = 0 ;
17751 void *argp1 = 0 ;
17752 int res1 = 0 ;
17753 void *argp2 = 0 ;
17754 int res2 = 0 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char * kwnames[] = {
17758 (char *) "self",(char *) "event", NULL
17759 };
17760
17761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17763 if (!SWIG_IsOK(res1)) {
17764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17765 }
17766 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17768 if (!SWIG_IsOK(res2)) {
17769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17770 }
17771 if (!argp2) {
17772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17773 }
17774 arg2 = reinterpret_cast< wxEvent * >(argp2);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 (arg1)->AddPendingEvent(*arg2);
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 resultobj = SWIG_Py_Void();
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17789 PyObject *resultobj = 0;
17790 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17791 void *argp1 = 0 ;
17792 int res1 = 0 ;
17793 PyObject *swig_obj[1] ;
17794
17795 if (!args) SWIG_fail;
17796 swig_obj[0] = args;
17797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17798 if (!SWIG_IsOK(res1)) {
17799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17800 }
17801 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 (arg1)->ProcessPendingEvents();
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 resultobj = SWIG_Py_Void();
17809 return resultobj;
17810 fail:
17811 return NULL;
17812 }
17813
17814
17815 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17816 PyObject *resultobj = 0;
17817 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17818 int arg2 ;
17819 int arg3 ;
17820 int arg4 ;
17821 PyObject *arg5 = (PyObject *) 0 ;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 int val2 ;
17825 int ecode2 = 0 ;
17826 int val3 ;
17827 int ecode3 = 0 ;
17828 int val4 ;
17829 int ecode4 = 0 ;
17830 PyObject * obj0 = 0 ;
17831 PyObject * obj1 = 0 ;
17832 PyObject * obj2 = 0 ;
17833 PyObject * obj3 = 0 ;
17834 PyObject * obj4 = 0 ;
17835 char * kwnames[] = {
17836 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17837 };
17838
17839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17843 }
17844 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17845 ecode2 = SWIG_AsVal_int(obj1, &val2);
17846 if (!SWIG_IsOK(ecode2)) {
17847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17848 }
17849 arg2 = static_cast< int >(val2);
17850 ecode3 = SWIG_AsVal_int(obj2, &val3);
17851 if (!SWIG_IsOK(ecode3)) {
17852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17853 }
17854 arg3 = static_cast< int >(val3);
17855 ecode4 = SWIG_AsVal_int(obj3, &val4);
17856 if (!SWIG_IsOK(ecode4)) {
17857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17858 }
17859 arg4 = static_cast< int >(val4);
17860 arg5 = obj4;
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 resultobj = SWIG_Py_Void();
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17875 PyObject *resultobj = 0;
17876 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17877 int arg2 ;
17878 int arg3 = (int) -1 ;
17879 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17880 bool result;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 int val2 ;
17884 int ecode2 = 0 ;
17885 int val3 ;
17886 int ecode3 = 0 ;
17887 int val4 ;
17888 int ecode4 = 0 ;
17889 PyObject * obj0 = 0 ;
17890 PyObject * obj1 = 0 ;
17891 PyObject * obj2 = 0 ;
17892 PyObject * obj3 = 0 ;
17893 char * kwnames[] = {
17894 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17895 };
17896
17897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17901 }
17902 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17903 ecode2 = SWIG_AsVal_int(obj1, &val2);
17904 if (!SWIG_IsOK(ecode2)) {
17905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17906 }
17907 arg2 = static_cast< int >(val2);
17908 if (obj2) {
17909 ecode3 = SWIG_AsVal_int(obj2, &val3);
17910 if (!SWIG_IsOK(ecode3)) {
17911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17912 }
17913 arg3 = static_cast< int >(val3);
17914 }
17915 if (obj3) {
17916 ecode4 = SWIG_AsVal_int(obj3, &val4);
17917 if (!SWIG_IsOK(ecode4)) {
17918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17919 }
17920 arg4 = static_cast< wxEventType >(val4);
17921 }
17922 {
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj = 0;
17939 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17940 PyObject *arg2 = (PyObject *) 0 ;
17941 bool arg3 = (bool) true ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 bool val3 ;
17945 int ecode3 = 0 ;
17946 PyObject * obj0 = 0 ;
17947 PyObject * obj1 = 0 ;
17948 PyObject * obj2 = 0 ;
17949 char * kwnames[] = {
17950 (char *) "self",(char *) "_self",(char *) "incref", NULL
17951 };
17952
17953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17955 if (!SWIG_IsOK(res1)) {
17956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17957 }
17958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17959 arg2 = obj1;
17960 if (obj2) {
17961 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17962 if (!SWIG_IsOK(ecode3)) {
17963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17964 }
17965 arg3 = static_cast< bool >(val3);
17966 }
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = SWIG_Py_Void();
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17981 PyObject *obj;
17982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17983 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17984 return SWIG_Py_Void();
17985 }
17986
17987 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17988 return SWIG_Python_InitShadowInstance(args);
17989 }
17990
17991 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17992 PyObject *resultobj = 0;
17993 wxEventType result;
17994
17995 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (wxEventType)wxNewEventType();
17999 wxPyEndAllowThreads(__tstate);
18000 if (PyErr_Occurred()) SWIG_fail;
18001 }
18002 resultobj = SWIG_From_int(static_cast< int >(result));
18003 return resultobj;
18004 fail:
18005 return NULL;
18006 }
18007
18008
18009 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18010 PyObject *resultobj = 0;
18011 wxEvent *arg1 = (wxEvent *) 0 ;
18012 void *argp1 = 0 ;
18013 int res1 = 0 ;
18014 PyObject *swig_obj[1] ;
18015
18016 if (!args) SWIG_fail;
18017 swig_obj[0] = args;
18018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18021 }
18022 arg1 = reinterpret_cast< wxEvent * >(argp1);
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 delete arg1;
18026
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = SWIG_Py_Void();
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj = 0;
18039 wxEvent *arg1 = (wxEvent *) 0 ;
18040 wxEventType arg2 ;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 int val2 ;
18044 int ecode2 = 0 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18047 char * kwnames[] = {
18048 (char *) "self",(char *) "typ", NULL
18049 };
18050
18051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18053 if (!SWIG_IsOK(res1)) {
18054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18055 }
18056 arg1 = reinterpret_cast< wxEvent * >(argp1);
18057 ecode2 = SWIG_AsVal_int(obj1, &val2);
18058 if (!SWIG_IsOK(ecode2)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18060 }
18061 arg2 = static_cast< wxEventType >(val2);
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 (arg1)->SetEventType(arg2);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_Py_Void();
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxEvent *arg1 = (wxEvent *) 0 ;
18078 wxEventType result;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18088 }
18089 arg1 = reinterpret_cast< wxEvent * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_From_int(static_cast< int >(result));
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxEvent *arg1 = (wxEvent *) 0 ;
18106 wxObject *result = 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvent * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 resultobj = wxPyMake_wxObject(result, (bool)0);
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj = 0;
18135 wxEvent *arg1 = (wxEvent *) 0 ;
18136 wxObject *arg2 = (wxObject *) 0 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 void *argp2 = 0 ;
18140 int res2 = 0 ;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char * kwnames[] = {
18144 (char *) "self",(char *) "obj", NULL
18145 };
18146
18147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18149 if (!SWIG_IsOK(res1)) {
18150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18151 }
18152 arg1 = reinterpret_cast< wxEvent * >(argp1);
18153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18154 if (!SWIG_IsOK(res2)) {
18155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18156 }
18157 arg2 = reinterpret_cast< wxObject * >(argp2);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 (arg1)->SetEventObject(arg2);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_Py_Void();
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxEvent *arg1 = (wxEvent *) 0 ;
18174 long result;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18184 }
18185 arg1 = reinterpret_cast< wxEvent * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_From_long(static_cast< long >(result));
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18200 PyObject *resultobj = 0;
18201 wxEvent *arg1 = (wxEvent *) 0 ;
18202 long arg2 = (long) 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 long val2 ;
18206 int ecode2 = 0 ;
18207 PyObject * obj0 = 0 ;
18208 PyObject * obj1 = 0 ;
18209 char * kwnames[] = {
18210 (char *) "self",(char *) "ts", NULL
18211 };
18212
18213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18215 if (!SWIG_IsOK(res1)) {
18216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18217 }
18218 arg1 = reinterpret_cast< wxEvent * >(argp1);
18219 if (obj1) {
18220 ecode2 = SWIG_AsVal_long(obj1, &val2);
18221 if (!SWIG_IsOK(ecode2)) {
18222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18223 }
18224 arg2 = static_cast< long >(val2);
18225 }
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 (arg1)->SetTimestamp(arg2);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = SWIG_Py_Void();
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18240 PyObject *resultobj = 0;
18241 wxEvent *arg1 = (wxEvent *) 0 ;
18242 int result;
18243 void *argp1 = 0 ;
18244 int res1 = 0 ;
18245 PyObject *swig_obj[1] ;
18246
18247 if (!args) SWIG_fail;
18248 swig_obj[0] = args;
18249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18250 if (!SWIG_IsOK(res1)) {
18251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18252 }
18253 arg1 = reinterpret_cast< wxEvent * >(argp1);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (int)((wxEvent const *)arg1)->GetId();
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_From_int(static_cast< int >(result));
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 int arg2 ;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 int val2 ;
18274 int ecode2 = 0 ;
18275 PyObject * obj0 = 0 ;
18276 PyObject * obj1 = 0 ;
18277 char * kwnames[] = {
18278 (char *) "self",(char *) "Id", NULL
18279 };
18280
18281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18283 if (!SWIG_IsOK(res1)) {
18284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18285 }
18286 arg1 = reinterpret_cast< wxEvent * >(argp1);
18287 ecode2 = SWIG_AsVal_int(obj1, &val2);
18288 if (!SWIG_IsOK(ecode2)) {
18289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18290 }
18291 arg2 = static_cast< int >(val2);
18292 {
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 (arg1)->SetId(arg2);
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 resultobj = SWIG_Py_Void();
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18306 PyObject *resultobj = 0;
18307 wxEvent *arg1 = (wxEvent *) 0 ;
18308 bool result;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 PyObject *swig_obj[1] ;
18312
18313 if (!args) SWIG_fail;
18314 swig_obj[0] = args;
18315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18316 if (!SWIG_IsOK(res1)) {
18317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18318 }
18319 arg1 = reinterpret_cast< wxEvent * >(argp1);
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 {
18327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj = 0;
18337 wxEvent *arg1 = (wxEvent *) 0 ;
18338 bool arg2 = (bool) true ;
18339 void *argp1 = 0 ;
18340 int res1 = 0 ;
18341 bool val2 ;
18342 int ecode2 = 0 ;
18343 PyObject * obj0 = 0 ;
18344 PyObject * obj1 = 0 ;
18345 char * kwnames[] = {
18346 (char *) "self",(char *) "skip", NULL
18347 };
18348
18349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18351 if (!SWIG_IsOK(res1)) {
18352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18353 }
18354 arg1 = reinterpret_cast< wxEvent * >(argp1);
18355 if (obj1) {
18356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18357 if (!SWIG_IsOK(ecode2)) {
18358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18359 }
18360 arg2 = static_cast< bool >(val2);
18361 }
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 (arg1)->Skip(arg2);
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = SWIG_Py_Void();
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18376 PyObject *resultobj = 0;
18377 wxEvent *arg1 = (wxEvent *) 0 ;
18378 bool result;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 PyObject *swig_obj[1] ;
18382
18383 if (!args) SWIG_fail;
18384 swig_obj[0] = args;
18385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18386 if (!SWIG_IsOK(res1)) {
18387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18388 }
18389 arg1 = reinterpret_cast< wxEvent * >(argp1);
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18406 PyObject *resultobj = 0;
18407 wxEvent *arg1 = (wxEvent *) 0 ;
18408 bool result;
18409 void *argp1 = 0 ;
18410 int res1 = 0 ;
18411 PyObject *swig_obj[1] ;
18412
18413 if (!args) SWIG_fail;
18414 swig_obj[0] = args;
18415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18416 if (!SWIG_IsOK(res1)) {
18417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18418 }
18419 arg1 = reinterpret_cast< wxEvent * >(argp1);
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18423 wxPyEndAllowThreads(__tstate);
18424 if (PyErr_Occurred()) SWIG_fail;
18425 }
18426 {
18427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18428 }
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18436 PyObject *resultobj = 0;
18437 wxEvent *arg1 = (wxEvent *) 0 ;
18438 int result;
18439 void *argp1 = 0 ;
18440 int res1 = 0 ;
18441 PyObject *swig_obj[1] ;
18442
18443 if (!args) SWIG_fail;
18444 swig_obj[0] = args;
18445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18446 if (!SWIG_IsOK(res1)) {
18447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18448 }
18449 arg1 = reinterpret_cast< wxEvent * >(argp1);
18450 {
18451 PyThreadState* __tstate = wxPyBeginAllowThreads();
18452 result = (int)(arg1)->StopPropagation();
18453 wxPyEndAllowThreads(__tstate);
18454 if (PyErr_Occurred()) SWIG_fail;
18455 }
18456 resultobj = SWIG_From_int(static_cast< int >(result));
18457 return resultobj;
18458 fail:
18459 return NULL;
18460 }
18461
18462
18463 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18464 PyObject *resultobj = 0;
18465 wxEvent *arg1 = (wxEvent *) 0 ;
18466 int arg2 ;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 int val2 ;
18470 int ecode2 = 0 ;
18471 PyObject * obj0 = 0 ;
18472 PyObject * obj1 = 0 ;
18473 char * kwnames[] = {
18474 (char *) "self",(char *) "propagationLevel", NULL
18475 };
18476
18477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18479 if (!SWIG_IsOK(res1)) {
18480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18481 }
18482 arg1 = reinterpret_cast< wxEvent * >(argp1);
18483 ecode2 = SWIG_AsVal_int(obj1, &val2);
18484 if (!SWIG_IsOK(ecode2)) {
18485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18486 }
18487 arg2 = static_cast< int >(val2);
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 (arg1)->ResumePropagation(arg2);
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = SWIG_Py_Void();
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18502 PyObject *resultobj = 0;
18503 wxEvent *arg1 = (wxEvent *) 0 ;
18504 wxEvent *result = 0 ;
18505 void *argp1 = 0 ;
18506 int res1 = 0 ;
18507 PyObject *swig_obj[1] ;
18508
18509 if (!args) SWIG_fail;
18510 swig_obj[0] = args;
18511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18512 if (!SWIG_IsOK(res1)) {
18513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18514 }
18515 arg1 = reinterpret_cast< wxEvent * >(argp1);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (wxEvent *)(arg1)->Clone();
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *obj;
18531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18532 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18533 return SWIG_Py_Void();
18534 }
18535
18536 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj = 0;
18538 wxEvent *arg1 = 0 ;
18539 wxPropagationDisabler *result = 0 ;
18540 void *argp1 = 0 ;
18541 int res1 = 0 ;
18542 PyObject * obj0 = 0 ;
18543 char * kwnames[] = {
18544 (char *) "event", NULL
18545 };
18546
18547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18548 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18551 }
18552 if (!argp1) {
18553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18554 }
18555 arg1 = reinterpret_cast< wxEvent * >(argp1);
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18570 PyObject *resultobj = 0;
18571 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18572 void *argp1 = 0 ;
18573 int res1 = 0 ;
18574 PyObject *swig_obj[1] ;
18575
18576 if (!args) SWIG_fail;
18577 swig_obj[0] = args;
18578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18579 if (!SWIG_IsOK(res1)) {
18580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18581 }
18582 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 delete arg1;
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *obj;
18599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18600 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18601 return SWIG_Py_Void();
18602 }
18603
18604 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18605 return SWIG_Python_InitShadowInstance(args);
18606 }
18607
18608 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = 0;
18610 wxEvent *arg1 = 0 ;
18611 wxPropagateOnce *result = 0 ;
18612 void *argp1 = 0 ;
18613 int res1 = 0 ;
18614 PyObject * obj0 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "event", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18623 }
18624 if (!argp1) {
18625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18626 }
18627 arg1 = reinterpret_cast< wxEvent * >(argp1);
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642 PyObject *resultobj = 0;
18643 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18644 void *argp1 = 0 ;
18645 int res1 = 0 ;
18646 PyObject *swig_obj[1] ;
18647
18648 if (!args) SWIG_fail;
18649 swig_obj[0] = args;
18650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18651 if (!SWIG_IsOK(res1)) {
18652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18653 }
18654 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 delete arg1;
18658
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_Py_Void();
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18670 PyObject *obj;
18671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18673 return SWIG_Py_Void();
18674 }
18675
18676 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18677 return SWIG_Python_InitShadowInstance(args);
18678 }
18679
18680 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18683 int arg2 = (int) 0 ;
18684 wxCommandEvent *result = 0 ;
18685 int val1 ;
18686 int ecode1 = 0 ;
18687 int val2 ;
18688 int ecode2 = 0 ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 char * kwnames[] = {
18692 (char *) "commandType",(char *) "winid", NULL
18693 };
18694
18695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18696 if (obj0) {
18697 ecode1 = SWIG_AsVal_int(obj0, &val1);
18698 if (!SWIG_IsOK(ecode1)) {
18699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18700 }
18701 arg1 = static_cast< wxEventType >(val1);
18702 }
18703 if (obj1) {
18704 ecode2 = SWIG_AsVal_int(obj1, &val2);
18705 if (!SWIG_IsOK(ecode2)) {
18706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18707 }
18708 arg2 = static_cast< int >(val2);
18709 }
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18724 PyObject *resultobj = 0;
18725 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18726 int result;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 PyObject *swig_obj[1] ;
18730
18731 if (!args) SWIG_fail;
18732 swig_obj[0] = args;
18733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18734 if (!SWIG_IsOK(res1)) {
18735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18736 }
18737 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18738 {
18739 PyThreadState* __tstate = wxPyBeginAllowThreads();
18740 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 resultobj = SWIG_From_int(static_cast< int >(result));
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18752 PyObject *resultobj = 0;
18753 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18754 wxString *arg2 = 0 ;
18755 void *argp1 = 0 ;
18756 int res1 = 0 ;
18757 bool temp2 = false ;
18758 PyObject * obj0 = 0 ;
18759 PyObject * obj1 = 0 ;
18760 char * kwnames[] = {
18761 (char *) "self",(char *) "s", NULL
18762 };
18763
18764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18766 if (!SWIG_IsOK(res1)) {
18767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18768 }
18769 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18770 {
18771 arg2 = wxString_in_helper(obj1);
18772 if (arg2 == NULL) SWIG_fail;
18773 temp2 = true;
18774 }
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 (arg1)->SetString((wxString const &)*arg2);
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 resultobj = SWIG_Py_Void();
18782 {
18783 if (temp2)
18784 delete arg2;
18785 }
18786 return resultobj;
18787 fail:
18788 {
18789 if (temp2)
18790 delete arg2;
18791 }
18792 return NULL;
18793 }
18794
18795
18796 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18797 PyObject *resultobj = 0;
18798 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18799 wxString result;
18800 void *argp1 = 0 ;
18801 int res1 = 0 ;
18802 PyObject *swig_obj[1] ;
18803
18804 if (!args) SWIG_fail;
18805 swig_obj[0] = args;
18806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18807 if (!SWIG_IsOK(res1)) {
18808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18809 }
18810 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 result = ((wxCommandEvent const *)arg1)->GetString();
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 {
18818 #if wxUSE_UNICODE
18819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18820 #else
18821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18822 #endif
18823 }
18824 return resultobj;
18825 fail:
18826 return NULL;
18827 }
18828
18829
18830 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18831 PyObject *resultobj = 0;
18832 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18833 bool result;
18834 void *argp1 = 0 ;
18835 int res1 = 0 ;
18836 PyObject *swig_obj[1] ;
18837
18838 if (!args) SWIG_fail;
18839 swig_obj[0] = args;
18840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18841 if (!SWIG_IsOK(res1)) {
18842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18843 }
18844 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 {
18852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18853 }
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18861 PyObject *resultobj = 0;
18862 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18863 bool result;
18864 void *argp1 = 0 ;
18865 int res1 = 0 ;
18866 PyObject *swig_obj[1] ;
18867
18868 if (!args) SWIG_fail;
18869 swig_obj[0] = args;
18870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18871 if (!SWIG_IsOK(res1)) {
18872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18873 }
18874 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18875 {
18876 PyThreadState* __tstate = wxPyBeginAllowThreads();
18877 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 {
18882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18883 }
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18891 PyObject *resultobj = 0;
18892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18893 long arg2 ;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 long val2 ;
18897 int ecode2 = 0 ;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char * kwnames[] = {
18901 (char *) "self",(char *) "extraLong", NULL
18902 };
18903
18904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18906 if (!SWIG_IsOK(res1)) {
18907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18908 }
18909 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18910 ecode2 = SWIG_AsVal_long(obj1, &val2);
18911 if (!SWIG_IsOK(ecode2)) {
18912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18913 }
18914 arg2 = static_cast< long >(val2);
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 (arg1)->SetExtraLong(arg2);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_Py_Void();
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18929 PyObject *resultobj = 0;
18930 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18931 long result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 PyObject *swig_obj[1] ;
18935
18936 if (!args) SWIG_fail;
18937 swig_obj[0] = args;
18938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18939 if (!SWIG_IsOK(res1)) {
18940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18941 }
18942 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18943 {
18944 PyThreadState* __tstate = wxPyBeginAllowThreads();
18945 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18946 wxPyEndAllowThreads(__tstate);
18947 if (PyErr_Occurred()) SWIG_fail;
18948 }
18949 resultobj = SWIG_From_long(static_cast< long >(result));
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 int arg2 ;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 int val2 ;
18963 int ecode2 = 0 ;
18964 PyObject * obj0 = 0 ;
18965 PyObject * obj1 = 0 ;
18966 char * kwnames[] = {
18967 (char *) "self",(char *) "i", NULL
18968 };
18969
18970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18972 if (!SWIG_IsOK(res1)) {
18973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18974 }
18975 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18976 ecode2 = SWIG_AsVal_int(obj1, &val2);
18977 if (!SWIG_IsOK(ecode2)) {
18978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18979 }
18980 arg2 = static_cast< int >(val2);
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 (arg1)->SetInt(arg2);
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 resultobj = SWIG_Py_Void();
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18995 PyObject *resultobj = 0;
18996 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18997 long result;
18998 void *argp1 = 0 ;
18999 int res1 = 0 ;
19000 PyObject *swig_obj[1] ;
19001
19002 if (!args) SWIG_fail;
19003 swig_obj[0] = args;
19004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19005 if (!SWIG_IsOK(res1)) {
19006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19007 }
19008 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_From_long(static_cast< long >(result));
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 PyObject *result = 0 ;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = result;
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 PyObject *arg2 = (PyObject *) 0 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject * obj0 = 0 ;
19057 PyObject * obj1 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "clientData", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19066 }
19067 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19068 arg2 = obj1;
19069 {
19070 PyThreadState* __tstate = wxPyBeginAllowThreads();
19071 wxCommandEvent_SetClientData(arg1,arg2);
19072 wxPyEndAllowThreads(__tstate);
19073 if (PyErr_Occurred()) SWIG_fail;
19074 }
19075 resultobj = SWIG_Py_Void();
19076 return resultobj;
19077 fail:
19078 return NULL;
19079 }
19080
19081
19082 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19083 PyObject *resultobj = 0;
19084 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19085 wxEvent *result = 0 ;
19086 void *argp1 = 0 ;
19087 int res1 = 0 ;
19088 PyObject *swig_obj[1] ;
19089
19090 if (!args) SWIG_fail;
19091 swig_obj[0] = args;
19092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19093 if (!SWIG_IsOK(res1)) {
19094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19095 }
19096 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19100 wxPyEndAllowThreads(__tstate);
19101 if (PyErr_Occurred()) SWIG_fail;
19102 }
19103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19104 return resultobj;
19105 fail:
19106 return NULL;
19107 }
19108
19109
19110 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19111 PyObject *obj;
19112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19113 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19114 return SWIG_Py_Void();
19115 }
19116
19117 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19118 return SWIG_Python_InitShadowInstance(args);
19119 }
19120
19121 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj = 0;
19123 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19124 int arg2 = (int) 0 ;
19125 wxNotifyEvent *result = 0 ;
19126 int val1 ;
19127 int ecode1 = 0 ;
19128 int val2 ;
19129 int ecode2 = 0 ;
19130 PyObject * obj0 = 0 ;
19131 PyObject * obj1 = 0 ;
19132 char * kwnames[] = {
19133 (char *) "commandType",(char *) "winid", NULL
19134 };
19135
19136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19137 if (obj0) {
19138 ecode1 = SWIG_AsVal_int(obj0, &val1);
19139 if (!SWIG_IsOK(ecode1)) {
19140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19141 }
19142 arg1 = static_cast< wxEventType >(val1);
19143 }
19144 if (obj1) {
19145 ecode2 = SWIG_AsVal_int(obj1, &val2);
19146 if (!SWIG_IsOK(ecode2)) {
19147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19148 }
19149 arg2 = static_cast< int >(val2);
19150 }
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165 PyObject *resultobj = 0;
19166 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 PyObject *swig_obj[1] ;
19170
19171 if (!args) SWIG_fail;
19172 swig_obj[0] = args;
19173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19176 }
19177 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 (arg1)->Veto();
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 resultobj = SWIG_Py_Void();
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19192 PyObject *resultobj = 0;
19193 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 PyObject *swig_obj[1] ;
19197
19198 if (!args) SWIG_fail;
19199 swig_obj[0] = args;
19200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19201 if (!SWIG_IsOK(res1)) {
19202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19203 }
19204 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 (arg1)->Allow();
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_Py_Void();
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19219 PyObject *resultobj = 0;
19220 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19221 bool result;
19222 void *argp1 = 0 ;
19223 int res1 = 0 ;
19224 PyObject *swig_obj[1] ;
19225
19226 if (!args) SWIG_fail;
19227 swig_obj[0] = args;
19228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19231 }
19232 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)(arg1)->IsAllowed();
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 {
19240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19241 }
19242 return resultobj;
19243 fail:
19244 return NULL;
19245 }
19246
19247
19248 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19249 PyObject *obj;
19250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19251 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19252 return SWIG_Py_Void();
19253 }
19254
19255 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19256 return SWIG_Python_InitShadowInstance(args);
19257 }
19258
19259 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19262 int arg2 = (int) 0 ;
19263 int arg3 = (int) 0 ;
19264 int arg4 = (int) 0 ;
19265 wxScrollEvent *result = 0 ;
19266 int val1 ;
19267 int ecode1 = 0 ;
19268 int val2 ;
19269 int ecode2 = 0 ;
19270 int val3 ;
19271 int ecode3 = 0 ;
19272 int val4 ;
19273 int ecode4 = 0 ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 PyObject * obj2 = 0 ;
19277 PyObject * obj3 = 0 ;
19278 char * kwnames[] = {
19279 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19280 };
19281
19282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19283 if (obj0) {
19284 ecode1 = SWIG_AsVal_int(obj0, &val1);
19285 if (!SWIG_IsOK(ecode1)) {
19286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19287 }
19288 arg1 = static_cast< wxEventType >(val1);
19289 }
19290 if (obj1) {
19291 ecode2 = SWIG_AsVal_int(obj1, &val2);
19292 if (!SWIG_IsOK(ecode2)) {
19293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19294 }
19295 arg2 = static_cast< int >(val2);
19296 }
19297 if (obj2) {
19298 ecode3 = SWIG_AsVal_int(obj2, &val3);
19299 if (!SWIG_IsOK(ecode3)) {
19300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19301 }
19302 arg3 = static_cast< int >(val3);
19303 }
19304 if (obj3) {
19305 ecode4 = SWIG_AsVal_int(obj3, &val4);
19306 if (!SWIG_IsOK(ecode4)) {
19307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19308 }
19309 arg4 = static_cast< int >(val4);
19310 }
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 PyObject *resultobj = 0;
19326 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19327 int result;
19328 void *argp1 = 0 ;
19329 int res1 = 0 ;
19330 PyObject *swig_obj[1] ;
19331
19332 if (!args) SWIG_fail;
19333 swig_obj[0] = args;
19334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19335 if (!SWIG_IsOK(res1)) {
19336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19337 }
19338 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 resultobj = SWIG_From_int(static_cast< int >(result));
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19353 PyObject *resultobj = 0;
19354 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19355 int result;
19356 void *argp1 = 0 ;
19357 int res1 = 0 ;
19358 PyObject *swig_obj[1] ;
19359
19360 if (!args) SWIG_fail;
19361 swig_obj[0] = args;
19362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19363 if (!SWIG_IsOK(res1)) {
19364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19365 }
19366 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19367 {
19368 PyThreadState* __tstate = wxPyBeginAllowThreads();
19369 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19370 wxPyEndAllowThreads(__tstate);
19371 if (PyErr_Occurred()) SWIG_fail;
19372 }
19373 resultobj = SWIG_From_int(static_cast< int >(result));
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19381 PyObject *resultobj = 0;
19382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19383 int arg2 ;
19384 void *argp1 = 0 ;
19385 int res1 = 0 ;
19386 int val2 ;
19387 int ecode2 = 0 ;
19388 PyObject * obj0 = 0 ;
19389 PyObject * obj1 = 0 ;
19390 char * kwnames[] = {
19391 (char *) "self",(char *) "orient", NULL
19392 };
19393
19394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19396 if (!SWIG_IsOK(res1)) {
19397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19398 }
19399 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19400 ecode2 = SWIG_AsVal_int(obj1, &val2);
19401 if (!SWIG_IsOK(ecode2)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19403 }
19404 arg2 = static_cast< int >(val2);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 (arg1)->SetOrientation(arg2);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_Py_Void();
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19421 int arg2 ;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 int val2 ;
19425 int ecode2 = 0 ;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char * kwnames[] = {
19429 (char *) "self",(char *) "pos", NULL
19430 };
19431
19432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19434 if (!SWIG_IsOK(res1)) {
19435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19436 }
19437 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19438 ecode2 = SWIG_AsVal_int(obj1, &val2);
19439 if (!SWIG_IsOK(ecode2)) {
19440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19441 }
19442 arg2 = static_cast< int >(val2);
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 (arg1)->SetPosition(arg2);
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 resultobj = SWIG_Py_Void();
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19457 PyObject *obj;
19458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19459 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19460 return SWIG_Py_Void();
19461 }
19462
19463 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19464 return SWIG_Python_InitShadowInstance(args);
19465 }
19466
19467 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj = 0;
19469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19470 int arg2 = (int) 0 ;
19471 int arg3 = (int) 0 ;
19472 wxScrollWinEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 int val3 ;
19478 int ecode3 = 0 ;
19479 PyObject * obj0 = 0 ;
19480 PyObject * obj1 = 0 ;
19481 PyObject * obj2 = 0 ;
19482 char * kwnames[] = {
19483 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19484 };
19485
19486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19487 if (obj0) {
19488 ecode1 = SWIG_AsVal_int(obj0, &val1);
19489 if (!SWIG_IsOK(ecode1)) {
19490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19491 }
19492 arg1 = static_cast< wxEventType >(val1);
19493 }
19494 if (obj1) {
19495 ecode2 = SWIG_AsVal_int(obj1, &val2);
19496 if (!SWIG_IsOK(ecode2)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19498 }
19499 arg2 = static_cast< int >(val2);
19500 }
19501 if (obj2) {
19502 ecode3 = SWIG_AsVal_int(obj2, &val3);
19503 if (!SWIG_IsOK(ecode3)) {
19504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19505 }
19506 arg3 = static_cast< int >(val3);
19507 }
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19511 wxPyEndAllowThreads(__tstate);
19512 if (PyErr_Occurred()) SWIG_fail;
19513 }
19514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19515 return resultobj;
19516 fail:
19517 return NULL;
19518 }
19519
19520
19521 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 PyObject *resultobj = 0;
19523 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19524 int result;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 PyObject *swig_obj[1] ;
19528
19529 if (!args) SWIG_fail;
19530 swig_obj[0] = args;
19531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19532 if (!SWIG_IsOK(res1)) {
19533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19534 }
19535 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 resultobj = SWIG_From_int(static_cast< int >(result));
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19550 PyObject *resultobj = 0;
19551 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19552 int result;
19553 void *argp1 = 0 ;
19554 int res1 = 0 ;
19555 PyObject *swig_obj[1] ;
19556
19557 if (!args) SWIG_fail;
19558 swig_obj[0] = args;
19559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19560 if (!SWIG_IsOK(res1)) {
19561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19562 }
19563 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_From_int(static_cast< int >(result));
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj = 0;
19579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19580 int arg2 ;
19581 void *argp1 = 0 ;
19582 int res1 = 0 ;
19583 int val2 ;
19584 int ecode2 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 char * kwnames[] = {
19588 (char *) "self",(char *) "orient", NULL
19589 };
19590
19591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19593 if (!SWIG_IsOK(res1)) {
19594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19595 }
19596 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19597 ecode2 = SWIG_AsVal_int(obj1, &val2);
19598 if (!SWIG_IsOK(ecode2)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19600 }
19601 arg2 = static_cast< int >(val2);
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 (arg1)->SetOrientation(arg2);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_Py_Void();
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19616 PyObject *resultobj = 0;
19617 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19618 int arg2 ;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 int val2 ;
19622 int ecode2 = 0 ;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 char * kwnames[] = {
19626 (char *) "self",(char *) "pos", NULL
19627 };
19628
19629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19631 if (!SWIG_IsOK(res1)) {
19632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19633 }
19634 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19635 ecode2 = SWIG_AsVal_int(obj1, &val2);
19636 if (!SWIG_IsOK(ecode2)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19638 }
19639 arg2 = static_cast< int >(val2);
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 (arg1)->SetPosition(arg2);
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_Py_Void();
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *obj;
19655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19656 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19657 return SWIG_Py_Void();
19658 }
19659
19660 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 return SWIG_Python_InitShadowInstance(args);
19662 }
19663
19664 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj = 0;
19666 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19667 wxMouseEvent *result = 0 ;
19668 int val1 ;
19669 int ecode1 = 0 ;
19670 PyObject * obj0 = 0 ;
19671 char * kwnames[] = {
19672 (char *) "mouseType", NULL
19673 };
19674
19675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19676 if (obj0) {
19677 ecode1 = SWIG_AsVal_int(obj0, &val1);
19678 if (!SWIG_IsOK(ecode1)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19680 }
19681 arg1 = static_cast< wxEventType >(val1);
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 {
19690 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19691 }
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19701 bool result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 {
19720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19721 }
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj = 0;
19730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19731 int arg2 = (int) wxMOUSE_BTN_ANY ;
19732 bool result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 int val2 ;
19736 int ecode2 = 0 ;
19737 PyObject * obj0 = 0 ;
19738 PyObject * obj1 = 0 ;
19739 char * kwnames[] = {
19740 (char *) "self",(char *) "but", NULL
19741 };
19742
19743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19745 if (!SWIG_IsOK(res1)) {
19746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19747 }
19748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19749 if (obj1) {
19750 ecode2 = SWIG_AsVal_int(obj1, &val2);
19751 if (!SWIG_IsOK(ecode2)) {
19752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19753 }
19754 arg2 = static_cast< int >(val2);
19755 }
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 {
19763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19764 }
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19772 PyObject *resultobj = 0;
19773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19774 int arg2 = (int) wxMOUSE_BTN_ANY ;
19775 bool result;
19776 void *argp1 = 0 ;
19777 int res1 = 0 ;
19778 int val2 ;
19779 int ecode2 = 0 ;
19780 PyObject * obj0 = 0 ;
19781 PyObject * obj1 = 0 ;
19782 char * kwnames[] = {
19783 (char *) "self",(char *) "but", NULL
19784 };
19785
19786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19788 if (!SWIG_IsOK(res1)) {
19789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19790 }
19791 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19792 if (obj1) {
19793 ecode2 = SWIG_AsVal_int(obj1, &val2);
19794 if (!SWIG_IsOK(ecode2)) {
19795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19796 }
19797 arg2 = static_cast< int >(val2);
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj = 0;
19816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19817 int arg2 = (int) wxMOUSE_BTN_ANY ;
19818 bool result;
19819 void *argp1 = 0 ;
19820 int res1 = 0 ;
19821 int val2 ;
19822 int ecode2 = 0 ;
19823 PyObject * obj0 = 0 ;
19824 PyObject * obj1 = 0 ;
19825 char * kwnames[] = {
19826 (char *) "self",(char *) "but", NULL
19827 };
19828
19829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19833 }
19834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19835 if (obj1) {
19836 ecode2 = SWIG_AsVal_int(obj1, &val2);
19837 if (!SWIG_IsOK(ecode2)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19839 }
19840 arg2 = static_cast< int >(val2);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19858 PyObject *resultobj = 0;
19859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19860 int arg2 ;
19861 bool result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 int val2 ;
19865 int ecode2 = 0 ;
19866 PyObject * obj0 = 0 ;
19867 PyObject * obj1 = 0 ;
19868 char * kwnames[] = {
19869 (char *) "self",(char *) "button", NULL
19870 };
19871
19872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19874 if (!SWIG_IsOK(res1)) {
19875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19876 }
19877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19878 ecode2 = SWIG_AsVal_int(obj1, &val2);
19879 if (!SWIG_IsOK(ecode2)) {
19880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19881 }
19882 arg2 = static_cast< int >(val2);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 {
19890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19891 }
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj = 0;
19900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19901 int arg2 ;
19902 bool result;
19903 void *argp1 = 0 ;
19904 int res1 = 0 ;
19905 int val2 ;
19906 int ecode2 = 0 ;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 char * kwnames[] = {
19910 (char *) "self",(char *) "but", NULL
19911 };
19912
19913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19917 }
19918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19919 ecode2 = SWIG_AsVal_int(obj1, &val2);
19920 if (!SWIG_IsOK(ecode2)) {
19921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19922 }
19923 arg2 = static_cast< int >(val2);
19924 {
19925 PyThreadState* __tstate = wxPyBeginAllowThreads();
19926 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19927 wxPyEndAllowThreads(__tstate);
19928 if (PyErr_Occurred()) SWIG_fail;
19929 }
19930 {
19931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19932 }
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19940 PyObject *resultobj = 0;
19941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19942 int result;
19943 void *argp1 = 0 ;
19944 int res1 = 0 ;
19945 PyObject *swig_obj[1] ;
19946
19947 if (!args) SWIG_fail;
19948 swig_obj[0] = args;
19949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19950 if (!SWIG_IsOK(res1)) {
19951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19952 }
19953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 resultobj = SWIG_From_int(static_cast< int >(result));
19961 return resultobj;
19962 fail:
19963 return NULL;
19964 }
19965
19966
19967 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19968 PyObject *resultobj = 0;
19969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19970 bool result;
19971 void *argp1 = 0 ;
19972 int res1 = 0 ;
19973 PyObject *swig_obj[1] ;
19974
19975 if (!args) SWIG_fail;
19976 swig_obj[0] = args;
19977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19978 if (!SWIG_IsOK(res1)) {
19979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19980 }
19981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 {
19989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19990 }
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19998 PyObject *resultobj = 0;
19999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20000 bool result;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject *swig_obj[1] ;
20004
20005 if (!args) SWIG_fail;
20006 swig_obj[0] = args;
20007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20010 }
20011 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 {
20019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20020 }
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20028 PyObject *resultobj = 0;
20029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20030 bool result;
20031 void *argp1 = 0 ;
20032 int res1 = 0 ;
20033 PyObject *swig_obj[1] ;
20034
20035 if (!args) SWIG_fail;
20036 swig_obj[0] = args;
20037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 {
20049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20050 }
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *resultobj = 0;
20059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20060 bool result;
20061 void *argp1 = 0 ;
20062 int res1 = 0 ;
20063 PyObject *swig_obj[1] ;
20064
20065 if (!args) SWIG_fail;
20066 swig_obj[0] = args;
20067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20068 if (!SWIG_IsOK(res1)) {
20069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20070 }
20071 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20080 }
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20088 PyObject *resultobj = 0;
20089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20090 bool result;
20091 void *argp1 = 0 ;
20092 int res1 = 0 ;
20093 PyObject *swig_obj[1] ;
20094
20095 if (!args) SWIG_fail;
20096 swig_obj[0] = args;
20097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20098 if (!SWIG_IsOK(res1)) {
20099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20100 }
20101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20118 PyObject *resultobj = 0;
20119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20120 bool result;
20121 void *argp1 = 0 ;
20122 int res1 = 0 ;
20123 PyObject *swig_obj[1] ;
20124
20125 if (!args) SWIG_fail;
20126 swig_obj[0] = args;
20127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20128 if (!SWIG_IsOK(res1)) {
20129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20130 }
20131 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *resultobj = 0;
20149 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20150 bool result;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 PyObject *swig_obj[1] ;
20154
20155 if (!args) SWIG_fail;
20156 swig_obj[0] = args;
20157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20158 if (!SWIG_IsOK(res1)) {
20159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20160 }
20161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 {
20169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20170 }
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20178 PyObject *resultobj = 0;
20179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20180 bool result;
20181 void *argp1 = 0 ;
20182 int res1 = 0 ;
20183 PyObject *swig_obj[1] ;
20184
20185 if (!args) SWIG_fail;
20186 swig_obj[0] = args;
20187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20188 if (!SWIG_IsOK(res1)) {
20189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20190 }
20191 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 {
20199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20200 }
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20208 PyObject *resultobj = 0;
20209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20210 bool result;
20211 void *argp1 = 0 ;
20212 int res1 = 0 ;
20213 PyObject *swig_obj[1] ;
20214
20215 if (!args) SWIG_fail;
20216 swig_obj[0] = args;
20217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20218 if (!SWIG_IsOK(res1)) {
20219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20220 }
20221 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20238 PyObject *resultobj = 0;
20239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20240 bool result;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 PyObject *swig_obj[1] ;
20244
20245 if (!args) SWIG_fail;
20246 swig_obj[0] = args;
20247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20248 if (!SWIG_IsOK(res1)) {
20249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20250 }
20251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20252 {
20253 PyThreadState* __tstate = wxPyBeginAllowThreads();
20254 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 {
20259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20260 }
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 PyObject *resultobj = 0;
20269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20270 bool result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 PyObject *swig_obj[1] ;
20274
20275 if (!args) SWIG_fail;
20276 swig_obj[0] = args;
20277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 {
20289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 PyObject *resultobj = 0;
20299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20300 bool result;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 PyObject *swig_obj[1] ;
20304
20305 if (!args) SWIG_fail;
20306 swig_obj[0] = args;
20307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20308 if (!SWIG_IsOK(res1)) {
20309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20310 }
20311 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 {
20319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20330 bool result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 PyObject *swig_obj[1] ;
20334
20335 if (!args) SWIG_fail;
20336 swig_obj[0] = args;
20337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20340 }
20341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20342 {
20343 PyThreadState* __tstate = wxPyBeginAllowThreads();
20344 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 {
20349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20350 }
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 PyObject *resultobj = 0;
20359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20360 bool result;
20361 void *argp1 = 0 ;
20362 int res1 = 0 ;
20363 PyObject *swig_obj[1] ;
20364
20365 if (!args) SWIG_fail;
20366 swig_obj[0] = args;
20367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20368 if (!SWIG_IsOK(res1)) {
20369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20370 }
20371 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20372 {
20373 PyThreadState* __tstate = wxPyBeginAllowThreads();
20374 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 {
20379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20380 }
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388 PyObject *resultobj = 0;
20389 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20390 bool result;
20391 void *argp1 = 0 ;
20392 int res1 = 0 ;
20393 PyObject *swig_obj[1] ;
20394
20395 if (!args) SWIG_fail;
20396 swig_obj[0] = args;
20397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20398 if (!SWIG_IsOK(res1)) {
20399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20400 }
20401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 result = (bool)(arg1)->LeftIsDown();
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 {
20409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20410 }
20411 return resultobj;
20412 fail:
20413 return NULL;
20414 }
20415
20416
20417 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20418 PyObject *resultobj = 0;
20419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20420 bool result;
20421 void *argp1 = 0 ;
20422 int res1 = 0 ;
20423 PyObject *swig_obj[1] ;
20424
20425 if (!args) SWIG_fail;
20426 swig_obj[0] = args;
20427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20428 if (!SWIG_IsOK(res1)) {
20429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20430 }
20431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20432 {
20433 PyThreadState* __tstate = wxPyBeginAllowThreads();
20434 result = (bool)(arg1)->MiddleIsDown();
20435 wxPyEndAllowThreads(__tstate);
20436 if (PyErr_Occurred()) SWIG_fail;
20437 }
20438 {
20439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20440 }
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20450 bool result;
20451 void *argp1 = 0 ;
20452 int res1 = 0 ;
20453 PyObject *swig_obj[1] ;
20454
20455 if (!args) SWIG_fail;
20456 swig_obj[0] = args;
20457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20458 if (!SWIG_IsOK(res1)) {
20459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20460 }
20461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (bool)(arg1)->RightIsDown();
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 {
20469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20470 }
20471 return resultobj;
20472 fail:
20473 return NULL;
20474 }
20475
20476
20477 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20478 PyObject *resultobj = 0;
20479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20480 bool result;
20481 void *argp1 = 0 ;
20482 int res1 = 0 ;
20483 PyObject *swig_obj[1] ;
20484
20485 if (!args) SWIG_fail;
20486 swig_obj[0] = args;
20487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20488 if (!SWIG_IsOK(res1)) {
20489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20490 }
20491 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20495 wxPyEndAllowThreads(__tstate);
20496 if (PyErr_Occurred()) SWIG_fail;
20497 }
20498 {
20499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20500 }
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20508 PyObject *resultobj = 0;
20509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20510 bool result;
20511 void *argp1 = 0 ;
20512 int res1 = 0 ;
20513 PyObject *swig_obj[1] ;
20514
20515 if (!args) SWIG_fail;
20516 swig_obj[0] = args;
20517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20518 if (!SWIG_IsOK(res1)) {
20519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20520 }
20521 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 {
20529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20530 }
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20540 bool result;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 PyObject *swig_obj[1] ;
20544
20545 if (!args) SWIG_fail;
20546 swig_obj[0] = args;
20547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20548 if (!SWIG_IsOK(res1)) {
20549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20550 }
20551 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 {
20559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20568 PyObject *resultobj = 0;
20569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20570 bool result;
20571 void *argp1 = 0 ;
20572 int res1 = 0 ;
20573 PyObject *swig_obj[1] ;
20574
20575 if (!args) SWIG_fail;
20576 swig_obj[0] = args;
20577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20578 if (!SWIG_IsOK(res1)) {
20579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20580 }
20581 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 {
20589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20590 }
20591 return resultobj;
20592 fail:
20593 return NULL;
20594 }
20595
20596
20597 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20598 PyObject *resultobj = 0;
20599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20600 wxPoint result;
20601 void *argp1 = 0 ;
20602 int res1 = 0 ;
20603 PyObject *swig_obj[1] ;
20604
20605 if (!args) SWIG_fail;
20606 swig_obj[0] = args;
20607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20608 if (!SWIG_IsOK(res1)) {
20609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20610 }
20611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 result = (arg1)->GetPosition();
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 long *arg2 = (long *) 0 ;
20629 long *arg3 = (long *) 0 ;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 long temp2 ;
20633 int res2 = SWIG_TMPOBJ ;
20634 long temp3 ;
20635 int res3 = SWIG_TMPOBJ ;
20636 PyObject *swig_obj[1] ;
20637
20638 arg2 = &temp2;
20639 arg3 = &temp3;
20640 if (!args) SWIG_fail;
20641 swig_obj[0] = args;
20642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20643 if (!SWIG_IsOK(res1)) {
20644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20645 }
20646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 (arg1)->GetPosition(arg2,arg3);
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 resultobj = SWIG_Py_Void();
20654 if (SWIG_IsTmpObj(res2)) {
20655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20656 } else {
20657 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20659 }
20660 if (SWIG_IsTmpObj(res3)) {
20661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20662 } else {
20663 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20673 PyObject *resultobj = 0;
20674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20675 wxDC *arg2 = 0 ;
20676 wxPoint result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 void *argp2 = 0 ;
20680 int res2 = 0 ;
20681 PyObject * obj0 = 0 ;
20682 PyObject * obj1 = 0 ;
20683 char * kwnames[] = {
20684 (char *) "self",(char *) "dc", NULL
20685 };
20686
20687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20689 if (!SWIG_IsOK(res1)) {
20690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20691 }
20692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20694 if (!SWIG_IsOK(res2)) {
20695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20696 }
20697 if (!argp2) {
20698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20699 }
20700 arg2 = reinterpret_cast< wxDC * >(argp2);
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 int result;
20718 void *argp1 = 0 ;
20719 int res1 = 0 ;
20720 PyObject *swig_obj[1] ;
20721
20722 if (!args) SWIG_fail;
20723 swig_obj[0] = args;
20724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20725 if (!SWIG_IsOK(res1)) {
20726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20727 }
20728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (int)((wxMouseEvent const *)arg1)->GetX();
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 resultobj = SWIG_From_int(static_cast< int >(result));
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20743 PyObject *resultobj = 0;
20744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20745 int result;
20746 void *argp1 = 0 ;
20747 int res1 = 0 ;
20748 PyObject *swig_obj[1] ;
20749
20750 if (!args) SWIG_fail;
20751 swig_obj[0] = args;
20752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20755 }
20756 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (int)((wxMouseEvent const *)arg1)->GetY();
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_From_int(static_cast< int >(result));
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20771 PyObject *resultobj = 0;
20772 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20773 int result;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 PyObject *swig_obj[1] ;
20777
20778 if (!args) SWIG_fail;
20779 swig_obj[0] = args;
20780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 resultobj = SWIG_From_int(static_cast< int >(result));
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20799 PyObject *resultobj = 0;
20800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20801 int result;
20802 void *argp1 = 0 ;
20803 int res1 = 0 ;
20804 PyObject *swig_obj[1] ;
20805
20806 if (!args) SWIG_fail;
20807 swig_obj[0] = args;
20808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20811 }
20812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_From_int(static_cast< int >(result));
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20829 int result;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 PyObject *swig_obj[1] ;
20833
20834 if (!args) SWIG_fail;
20835 swig_obj[0] = args;
20836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20839 }
20840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_From_int(static_cast< int >(result));
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20857 bool result;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 PyObject *swig_obj[1] ;
20861
20862 if (!args) SWIG_fail;
20863 swig_obj[0] = args;
20864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 {
20876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20877 }
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *resultobj = 0;
20886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20887 int arg2 ;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 int val2 ;
20891 int ecode2 = 0 ;
20892 PyObject *swig_obj[2] ;
20893
20894 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20896 if (!SWIG_IsOK(res1)) {
20897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20898 }
20899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20900 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20901 if (!SWIG_IsOK(ecode2)) {
20902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20903 }
20904 arg2 = static_cast< int >(val2);
20905 if (arg1) (arg1)->m_x = arg2;
20906
20907 resultobj = SWIG_Py_Void();
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 result = (int) ((arg1)->m_x);
20930 resultobj = SWIG_From_int(static_cast< int >(result));
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 PyObject *resultobj = 0;
20939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20940 int arg2 ;
20941 void *argp1 = 0 ;
20942 int res1 = 0 ;
20943 int val2 ;
20944 int ecode2 = 0 ;
20945 PyObject *swig_obj[2] ;
20946
20947 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20949 if (!SWIG_IsOK(res1)) {
20950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20951 }
20952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20953 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20954 if (!SWIG_IsOK(ecode2)) {
20955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20956 }
20957 arg2 = static_cast< int >(val2);
20958 if (arg1) (arg1)->m_y = arg2;
20959
20960 resultobj = SWIG_Py_Void();
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20968 PyObject *resultobj = 0;
20969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20970 int result;
20971 void *argp1 = 0 ;
20972 int res1 = 0 ;
20973 PyObject *swig_obj[1] ;
20974
20975 if (!args) SWIG_fail;
20976 swig_obj[0] = args;
20977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20978 if (!SWIG_IsOK(res1)) {
20979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20980 }
20981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20982 result = (int) ((arg1)->m_y);
20983 resultobj = SWIG_From_int(static_cast< int >(result));
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20991 PyObject *resultobj = 0;
20992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20993 bool arg2 ;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 bool val2 ;
20997 int ecode2 = 0 ;
20998 PyObject *swig_obj[2] ;
20999
21000 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21004 }
21005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21006 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21007 if (!SWIG_IsOK(ecode2)) {
21008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21009 }
21010 arg2 = static_cast< bool >(val2);
21011 if (arg1) (arg1)->m_leftDown = arg2;
21012
21013 resultobj = SWIG_Py_Void();
21014 return resultobj;
21015 fail:
21016 return NULL;
21017 }
21018
21019
21020 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21021 PyObject *resultobj = 0;
21022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21023 bool result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 PyObject *swig_obj[1] ;
21027
21028 if (!args) SWIG_fail;
21029 swig_obj[0] = args;
21030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21031 if (!SWIG_IsOK(res1)) {
21032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21033 }
21034 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21035 result = (bool) ((arg1)->m_leftDown);
21036 {
21037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21038 }
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21048 bool arg2 ;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 bool val2 ;
21052 int ecode2 = 0 ;
21053 PyObject *swig_obj[2] ;
21054
21055 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21062 if (!SWIG_IsOK(ecode2)) {
21063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21064 }
21065 arg2 = static_cast< bool >(val2);
21066 if (arg1) (arg1)->m_middleDown = arg2;
21067
21068 resultobj = SWIG_Py_Void();
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21076 PyObject *resultobj = 0;
21077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21078 bool result;
21079 void *argp1 = 0 ;
21080 int res1 = 0 ;
21081 PyObject *swig_obj[1] ;
21082
21083 if (!args) SWIG_fail;
21084 swig_obj[0] = args;
21085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21086 if (!SWIG_IsOK(res1)) {
21087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21088 }
21089 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21090 result = (bool) ((arg1)->m_middleDown);
21091 {
21092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21093 }
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21101 PyObject *resultobj = 0;
21102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21103 bool arg2 ;
21104 void *argp1 = 0 ;
21105 int res1 = 0 ;
21106 bool val2 ;
21107 int ecode2 = 0 ;
21108 PyObject *swig_obj[2] ;
21109
21110 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21112 if (!SWIG_IsOK(res1)) {
21113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21114 }
21115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21116 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21117 if (!SWIG_IsOK(ecode2)) {
21118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21119 }
21120 arg2 = static_cast< bool >(val2);
21121 if (arg1) (arg1)->m_rightDown = arg2;
21122
21123 resultobj = SWIG_Py_Void();
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21133 bool result;
21134 void *argp1 = 0 ;
21135 int res1 = 0 ;
21136 PyObject *swig_obj[1] ;
21137
21138 if (!args) SWIG_fail;
21139 swig_obj[0] = args;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21143 }
21144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21145 result = (bool) ((arg1)->m_rightDown);
21146 {
21147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21148 }
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21156 PyObject *resultobj = 0;
21157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21158 bool arg2 ;
21159 void *argp1 = 0 ;
21160 int res1 = 0 ;
21161 bool val2 ;
21162 int ecode2 = 0 ;
21163 PyObject *swig_obj[2] ;
21164
21165 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21167 if (!SWIG_IsOK(res1)) {
21168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21169 }
21170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21171 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21172 if (!SWIG_IsOK(ecode2)) {
21173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21174 }
21175 arg2 = static_cast< bool >(val2);
21176 if (arg1) (arg1)->m_controlDown = arg2;
21177
21178 resultobj = SWIG_Py_Void();
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21186 PyObject *resultobj = 0;
21187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21188 bool result;
21189 void *argp1 = 0 ;
21190 int res1 = 0 ;
21191 PyObject *swig_obj[1] ;
21192
21193 if (!args) SWIG_fail;
21194 swig_obj[0] = args;
21195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21196 if (!SWIG_IsOK(res1)) {
21197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21198 }
21199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21200 result = (bool) ((arg1)->m_controlDown);
21201 {
21202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21203 }
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 PyObject *resultobj = 0;
21212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21213 bool arg2 ;
21214 void *argp1 = 0 ;
21215 int res1 = 0 ;
21216 bool val2 ;
21217 int ecode2 = 0 ;
21218 PyObject *swig_obj[2] ;
21219
21220 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21222 if (!SWIG_IsOK(res1)) {
21223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21224 }
21225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21226 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21227 if (!SWIG_IsOK(ecode2)) {
21228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21229 }
21230 arg2 = static_cast< bool >(val2);
21231 if (arg1) (arg1)->m_shiftDown = arg2;
21232
21233 resultobj = SWIG_Py_Void();
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21241 PyObject *resultobj = 0;
21242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21243 bool result;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 PyObject *swig_obj[1] ;
21247
21248 if (!args) SWIG_fail;
21249 swig_obj[0] = args;
21250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21251 if (!SWIG_IsOK(res1)) {
21252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21253 }
21254 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21255 result = (bool) ((arg1)->m_shiftDown);
21256 {
21257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21258 }
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21266 PyObject *resultobj = 0;
21267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21268 bool arg2 ;
21269 void *argp1 = 0 ;
21270 int res1 = 0 ;
21271 bool val2 ;
21272 int ecode2 = 0 ;
21273 PyObject *swig_obj[2] ;
21274
21275 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21279 }
21280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21281 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21282 if (!SWIG_IsOK(ecode2)) {
21283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21284 }
21285 arg2 = static_cast< bool >(val2);
21286 if (arg1) (arg1)->m_altDown = arg2;
21287
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21298 bool result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21308 }
21309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21310 result = (bool) ((arg1)->m_altDown);
21311 {
21312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21313 }
21314 return resultobj;
21315 fail:
21316 return NULL;
21317 }
21318
21319
21320 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21321 PyObject *resultobj = 0;
21322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21323 bool arg2 ;
21324 void *argp1 = 0 ;
21325 int res1 = 0 ;
21326 bool val2 ;
21327 int ecode2 = 0 ;
21328 PyObject *swig_obj[2] ;
21329
21330 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21332 if (!SWIG_IsOK(res1)) {
21333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21334 }
21335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21336 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21337 if (!SWIG_IsOK(ecode2)) {
21338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21339 }
21340 arg2 = static_cast< bool >(val2);
21341 if (arg1) (arg1)->m_metaDown = arg2;
21342
21343 resultobj = SWIG_Py_Void();
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21351 PyObject *resultobj = 0;
21352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21353 bool result;
21354 void *argp1 = 0 ;
21355 int res1 = 0 ;
21356 PyObject *swig_obj[1] ;
21357
21358 if (!args) SWIG_fail;
21359 swig_obj[0] = args;
21360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21361 if (!SWIG_IsOK(res1)) {
21362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21363 }
21364 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21365 result = (bool) ((arg1)->m_metaDown);
21366 {
21367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21368 }
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21376 PyObject *resultobj = 0;
21377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21378 int arg2 ;
21379 void *argp1 = 0 ;
21380 int res1 = 0 ;
21381 int val2 ;
21382 int ecode2 = 0 ;
21383 PyObject *swig_obj[2] ;
21384
21385 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21389 }
21390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21391 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21392 if (!SWIG_IsOK(ecode2)) {
21393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21394 }
21395 arg2 = static_cast< int >(val2);
21396 if (arg1) (arg1)->m_wheelRotation = arg2;
21397
21398 resultobj = SWIG_Py_Void();
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21406 PyObject *resultobj = 0;
21407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21408 int result;
21409 void *argp1 = 0 ;
21410 int res1 = 0 ;
21411 PyObject *swig_obj[1] ;
21412
21413 if (!args) SWIG_fail;
21414 swig_obj[0] = args;
21415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21416 if (!SWIG_IsOK(res1)) {
21417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21418 }
21419 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21420 result = (int) ((arg1)->m_wheelRotation);
21421 resultobj = SWIG_From_int(static_cast< int >(result));
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21431 int arg2 ;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 int val2 ;
21435 int ecode2 = 0 ;
21436 PyObject *swig_obj[2] ;
21437
21438 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21440 if (!SWIG_IsOK(res1)) {
21441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21442 }
21443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21444 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21445 if (!SWIG_IsOK(ecode2)) {
21446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21447 }
21448 arg2 = static_cast< int >(val2);
21449 if (arg1) (arg1)->m_wheelDelta = arg2;
21450
21451 resultobj = SWIG_Py_Void();
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *resultobj = 0;
21460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21461 int result;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 PyObject *swig_obj[1] ;
21465
21466 if (!args) SWIG_fail;
21467 swig_obj[0] = args;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 result = (int) ((arg1)->m_wheelDelta);
21474 resultobj = SWIG_From_int(static_cast< int >(result));
21475 return resultobj;
21476 fail:
21477 return NULL;
21478 }
21479
21480
21481 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21482 PyObject *resultobj = 0;
21483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21484 int arg2 ;
21485 void *argp1 = 0 ;
21486 int res1 = 0 ;
21487 int val2 ;
21488 int ecode2 = 0 ;
21489 PyObject *swig_obj[2] ;
21490
21491 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21498 if (!SWIG_IsOK(ecode2)) {
21499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21500 }
21501 arg2 = static_cast< int >(val2);
21502 if (arg1) (arg1)->m_linesPerAction = arg2;
21503
21504 resultobj = SWIG_Py_Void();
21505 return resultobj;
21506 fail:
21507 return NULL;
21508 }
21509
21510
21511 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21512 PyObject *resultobj = 0;
21513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21514 int result;
21515 void *argp1 = 0 ;
21516 int res1 = 0 ;
21517 PyObject *swig_obj[1] ;
21518
21519 if (!args) SWIG_fail;
21520 swig_obj[0] = args;
21521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21522 if (!SWIG_IsOK(res1)) {
21523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21524 }
21525 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21526 result = (int) ((arg1)->m_linesPerAction);
21527 resultobj = SWIG_From_int(static_cast< int >(result));
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *obj;
21536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21537 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21538 return SWIG_Py_Void();
21539 }
21540
21541 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21542 return SWIG_Python_InitShadowInstance(args);
21543 }
21544
21545 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj = 0;
21547 int arg1 = (int) 0 ;
21548 int arg2 = (int) 0 ;
21549 wxSetCursorEvent *result = 0 ;
21550 int val1 ;
21551 int ecode1 = 0 ;
21552 int val2 ;
21553 int ecode2 = 0 ;
21554 PyObject * obj0 = 0 ;
21555 PyObject * obj1 = 0 ;
21556 char * kwnames[] = {
21557 (char *) "x",(char *) "y", NULL
21558 };
21559
21560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21561 if (obj0) {
21562 ecode1 = SWIG_AsVal_int(obj0, &val1);
21563 if (!SWIG_IsOK(ecode1)) {
21564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21565 }
21566 arg1 = static_cast< int >(val1);
21567 }
21568 if (obj1) {
21569 ecode2 = SWIG_AsVal_int(obj1, &val2);
21570 if (!SWIG_IsOK(ecode2)) {
21571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21572 }
21573 arg2 = static_cast< int >(val2);
21574 }
21575 {
21576 PyThreadState* __tstate = wxPyBeginAllowThreads();
21577 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21591 int result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21601 }
21602 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 resultobj = SWIG_From_int(static_cast< int >(result));
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21619 int result;
21620 void *argp1 = 0 ;
21621 int res1 = 0 ;
21622 PyObject *swig_obj[1] ;
21623
21624 if (!args) SWIG_fail;
21625 swig_obj[0] = args;
21626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21627 if (!SWIG_IsOK(res1)) {
21628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21629 }
21630 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_From_int(static_cast< int >(result));
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = 0;
21646 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21647 wxCursor *arg2 = 0 ;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 void *argp2 = 0 ;
21651 int res2 = 0 ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 char * kwnames[] = {
21655 (char *) "self",(char *) "cursor", NULL
21656 };
21657
21658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21662 }
21663 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21665 if (!SWIG_IsOK(res2)) {
21666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21667 }
21668 if (!argp2) {
21669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21670 }
21671 arg2 = reinterpret_cast< wxCursor * >(argp2);
21672 {
21673 PyThreadState* __tstate = wxPyBeginAllowThreads();
21674 (arg1)->SetCursor((wxCursor const &)*arg2);
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 resultobj = SWIG_Py_Void();
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 PyObject *resultobj = 0;
21687 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21688 wxCursor *result = 0 ;
21689 void *argp1 = 0 ;
21690 int res1 = 0 ;
21691 PyObject *swig_obj[1] ;
21692
21693 if (!args) SWIG_fail;
21694 swig_obj[0] = args;
21695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21696 if (!SWIG_IsOK(res1)) {
21697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21698 }
21699 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 {
21703 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21704 result = (wxCursor *) &_result_ref;
21705 }
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 {
21710 wxCursor* resultptr = new wxCursor(*result);
21711 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21712 }
21713 return resultobj;
21714 fail:
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21720 PyObject *resultobj = 0;
21721 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21722 bool result;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21732 }
21733 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 {
21741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21742 }
21743 return resultobj;
21744 fail:
21745 return NULL;
21746 }
21747
21748
21749 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21750 PyObject *obj;
21751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21752 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21753 return SWIG_Py_Void();
21754 }
21755
21756 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 return SWIG_Python_InitShadowInstance(args);
21758 }
21759
21760 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21761 PyObject *resultobj = 0;
21762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21763 wxKeyEvent *result = 0 ;
21764 int val1 ;
21765 int ecode1 = 0 ;
21766 PyObject * obj0 = 0 ;
21767 char * kwnames[] = {
21768 (char *) "eventType", NULL
21769 };
21770
21771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21772 if (obj0) {
21773 ecode1 = SWIG_AsVal_int(obj0, &val1);
21774 if (!SWIG_IsOK(ecode1)) {
21775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21776 }
21777 arg1 = static_cast< wxEventType >(val1);
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21793 PyObject *resultobj = 0;
21794 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21795 int result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 PyObject *swig_obj[1] ;
21799
21800 if (!args) SWIG_fail;
21801 swig_obj[0] = args;
21802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21803 if (!SWIG_IsOK(res1)) {
21804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21805 }
21806 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 resultobj = SWIG_From_int(static_cast< int >(result));
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 PyObject *resultobj = 0;
21822 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21823 bool result;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 PyObject *swig_obj[1] ;
21827
21828 if (!args) SWIG_fail;
21829 swig_obj[0] = args;
21830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21833 }
21834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21838 wxPyEndAllowThreads(__tstate);
21839 if (PyErr_Occurred()) SWIG_fail;
21840 }
21841 {
21842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21843 }
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21853 bool result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21873 }
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 PyObject *resultobj = 0;
21882 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21883 bool result;
21884 void *argp1 = 0 ;
21885 int res1 = 0 ;
21886 PyObject *swig_obj[1] ;
21887
21888 if (!args) SWIG_fail;
21889 swig_obj[0] = args;
21890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21891 if (!SWIG_IsOK(res1)) {
21892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21893 }
21894 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21895 {
21896 PyThreadState* __tstate = wxPyBeginAllowThreads();
21897 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21903 }
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21911 PyObject *resultobj = 0;
21912 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21913 bool result;
21914 void *argp1 = 0 ;
21915 int res1 = 0 ;
21916 PyObject *swig_obj[1] ;
21917
21918 if (!args) SWIG_fail;
21919 swig_obj[0] = args;
21920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21921 if (!SWIG_IsOK(res1)) {
21922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21923 }
21924 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 {
21932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21933 }
21934 return resultobj;
21935 fail:
21936 return NULL;
21937 }
21938
21939
21940 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21941 PyObject *resultobj = 0;
21942 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21943 bool result;
21944 void *argp1 = 0 ;
21945 int res1 = 0 ;
21946 PyObject *swig_obj[1] ;
21947
21948 if (!args) SWIG_fail;
21949 swig_obj[0] = args;
21950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21951 if (!SWIG_IsOK(res1)) {
21952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21953 }
21954 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21958 wxPyEndAllowThreads(__tstate);
21959 if (PyErr_Occurred()) SWIG_fail;
21960 }
21961 {
21962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21963 }
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21971 PyObject *resultobj = 0;
21972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21973 bool result;
21974 void *argp1 = 0 ;
21975 int res1 = 0 ;
21976 PyObject *swig_obj[1] ;
21977
21978 if (!args) SWIG_fail;
21979 swig_obj[0] = args;
21980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21981 if (!SWIG_IsOK(res1)) {
21982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21983 }
21984 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 {
21992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21993 }
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22003 int result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_int(static_cast< int >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22031 int result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 PyObject *swig_obj[1] ;
22035
22036 if (!args) SWIG_fail;
22037 swig_obj[0] = args;
22038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22039 if (!SWIG_IsOK(res1)) {
22040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22041 }
22042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 resultobj = SWIG_From_int(static_cast< int >(result));
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 PyObject *resultobj = 0;
22058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22059 unsigned int result;
22060 void *argp1 = 0 ;
22061 int res1 = 0 ;
22062 PyObject *swig_obj[1] ;
22063
22064 if (!args) SWIG_fail;
22065 swig_obj[0] = args;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22069 }
22070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22087 unsigned int result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22113 PyObject *resultobj = 0;
22114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22115 wxPoint result;
22116 void *argp1 = 0 ;
22117 int res1 = 0 ;
22118 PyObject *swig_obj[1] ;
22119
22120 if (!args) SWIG_fail;
22121 swig_obj[0] = args;
22122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22123 if (!SWIG_IsOK(res1)) {
22124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22125 }
22126 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22127 {
22128 PyThreadState* __tstate = wxPyBeginAllowThreads();
22129 result = (arg1)->GetPosition();
22130 wxPyEndAllowThreads(__tstate);
22131 if (PyErr_Occurred()) SWIG_fail;
22132 }
22133 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22141 PyObject *resultobj = 0;
22142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22143 long *arg2 = (long *) 0 ;
22144 long *arg3 = (long *) 0 ;
22145 void *argp1 = 0 ;
22146 int res1 = 0 ;
22147 long temp2 ;
22148 int res2 = SWIG_TMPOBJ ;
22149 long temp3 ;
22150 int res3 = SWIG_TMPOBJ ;
22151 PyObject *swig_obj[1] ;
22152
22153 arg2 = &temp2;
22154 arg3 = &temp3;
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 (arg1)->GetPosition(arg2,arg3);
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_Py_Void();
22169 if (SWIG_IsTmpObj(res2)) {
22170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22171 } else {
22172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22174 }
22175 if (SWIG_IsTmpObj(res3)) {
22176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22177 } else {
22178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22180 }
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22188 PyObject *resultobj = 0;
22189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22190 int result;
22191 void *argp1 = 0 ;
22192 int res1 = 0 ;
22193 PyObject *swig_obj[1] ;
22194
22195 if (!args) SWIG_fail;
22196 swig_obj[0] = args;
22197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22198 if (!SWIG_IsOK(res1)) {
22199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22200 }
22201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (int)((wxKeyEvent const *)arg1)->GetX();
22205 wxPyEndAllowThreads(__tstate);
22206 if (PyErr_Occurred()) SWIG_fail;
22207 }
22208 resultobj = SWIG_From_int(static_cast< int >(result));
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22218 int result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22228 }
22229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (int)((wxKeyEvent const *)arg1)->GetY();
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 resultobj = SWIG_From_int(static_cast< int >(result));
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22244 PyObject *resultobj = 0;
22245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22246 int arg2 ;
22247 void *argp1 = 0 ;
22248 int res1 = 0 ;
22249 int val2 ;
22250 int ecode2 = 0 ;
22251 PyObject *swig_obj[2] ;
22252
22253 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22255 if (!SWIG_IsOK(res1)) {
22256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22257 }
22258 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22259 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22260 if (!SWIG_IsOK(ecode2)) {
22261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22262 }
22263 arg2 = static_cast< int >(val2);
22264 if (arg1) (arg1)->m_x = arg2;
22265
22266 resultobj = SWIG_Py_Void();
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22274 PyObject *resultobj = 0;
22275 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22276 int result;
22277 void *argp1 = 0 ;
22278 int res1 = 0 ;
22279 PyObject *swig_obj[1] ;
22280
22281 if (!args) SWIG_fail;
22282 swig_obj[0] = args;
22283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22284 if (!SWIG_IsOK(res1)) {
22285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22286 }
22287 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22288 result = (int) ((arg1)->m_x);
22289 resultobj = SWIG_From_int(static_cast< int >(result));
22290 return resultobj;
22291 fail:
22292 return NULL;
22293 }
22294
22295
22296 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22297 PyObject *resultobj = 0;
22298 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22299 int arg2 ;
22300 void *argp1 = 0 ;
22301 int res1 = 0 ;
22302 int val2 ;
22303 int ecode2 = 0 ;
22304 PyObject *swig_obj[2] ;
22305
22306 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22308 if (!SWIG_IsOK(res1)) {
22309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22310 }
22311 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22312 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22313 if (!SWIG_IsOK(ecode2)) {
22314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22315 }
22316 arg2 = static_cast< int >(val2);
22317 if (arg1) (arg1)->m_y = arg2;
22318
22319 resultobj = SWIG_Py_Void();
22320 return resultobj;
22321 fail:
22322 return NULL;
22323 }
22324
22325
22326 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327 PyObject *resultobj = 0;
22328 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22329 int result;
22330 void *argp1 = 0 ;
22331 int res1 = 0 ;
22332 PyObject *swig_obj[1] ;
22333
22334 if (!args) SWIG_fail;
22335 swig_obj[0] = args;
22336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22337 if (!SWIG_IsOK(res1)) {
22338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22339 }
22340 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22341 result = (int) ((arg1)->m_y);
22342 resultobj = SWIG_From_int(static_cast< int >(result));
22343 return resultobj;
22344 fail:
22345 return NULL;
22346 }
22347
22348
22349 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22350 PyObject *resultobj = 0;
22351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22352 long arg2 ;
22353 void *argp1 = 0 ;
22354 int res1 = 0 ;
22355 long val2 ;
22356 int ecode2 = 0 ;
22357 PyObject *swig_obj[2] ;
22358
22359 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22361 if (!SWIG_IsOK(res1)) {
22362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22363 }
22364 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22365 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22366 if (!SWIG_IsOK(ecode2)) {
22367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22368 }
22369 arg2 = static_cast< long >(val2);
22370 if (arg1) (arg1)->m_keyCode = arg2;
22371
22372 resultobj = SWIG_Py_Void();
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22380 PyObject *resultobj = 0;
22381 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22382 long result;
22383 void *argp1 = 0 ;
22384 int res1 = 0 ;
22385 PyObject *swig_obj[1] ;
22386
22387 if (!args) SWIG_fail;
22388 swig_obj[0] = args;
22389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22390 if (!SWIG_IsOK(res1)) {
22391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22392 }
22393 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22394 result = (long) ((arg1)->m_keyCode);
22395 resultobj = SWIG_From_long(static_cast< long >(result));
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22403 PyObject *resultobj = 0;
22404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22405 bool arg2 ;
22406 void *argp1 = 0 ;
22407 int res1 = 0 ;
22408 bool val2 ;
22409 int ecode2 = 0 ;
22410 PyObject *swig_obj[2] ;
22411
22412 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22416 }
22417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22418 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22419 if (!SWIG_IsOK(ecode2)) {
22420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22421 }
22422 arg2 = static_cast< bool >(val2);
22423 if (arg1) (arg1)->m_controlDown = arg2;
22424
22425 resultobj = SWIG_Py_Void();
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 bool 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_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 result = (bool) ((arg1)->m_controlDown);
22448 {
22449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22450 }
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22458 PyObject *resultobj = 0;
22459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22460 bool arg2 ;
22461 void *argp1 = 0 ;
22462 int res1 = 0 ;
22463 bool val2 ;
22464 int ecode2 = 0 ;
22465 PyObject *swig_obj[2] ;
22466
22467 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22469 if (!SWIG_IsOK(res1)) {
22470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22471 }
22472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22473 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22474 if (!SWIG_IsOK(ecode2)) {
22475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22476 }
22477 arg2 = static_cast< bool >(val2);
22478 if (arg1) (arg1)->m_shiftDown = arg2;
22479
22480 resultobj = SWIG_Py_Void();
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22488 PyObject *resultobj = 0;
22489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22490 bool result;
22491 void *argp1 = 0 ;
22492 int res1 = 0 ;
22493 PyObject *swig_obj[1] ;
22494
22495 if (!args) SWIG_fail;
22496 swig_obj[0] = args;
22497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22498 if (!SWIG_IsOK(res1)) {
22499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22500 }
22501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22502 result = (bool) ((arg1)->m_shiftDown);
22503 {
22504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22505 }
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *resultobj = 0;
22514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22515 bool arg2 ;
22516 void *argp1 = 0 ;
22517 int res1 = 0 ;
22518 bool val2 ;
22519 int ecode2 = 0 ;
22520 PyObject *swig_obj[2] ;
22521
22522 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22524 if (!SWIG_IsOK(res1)) {
22525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22526 }
22527 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22528 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22529 if (!SWIG_IsOK(ecode2)) {
22530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22531 }
22532 arg2 = static_cast< bool >(val2);
22533 if (arg1) (arg1)->m_altDown = arg2;
22534
22535 resultobj = SWIG_Py_Void();
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 PyObject *resultobj = 0;
22544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22545 bool result;
22546 void *argp1 = 0 ;
22547 int res1 = 0 ;
22548 PyObject *swig_obj[1] ;
22549
22550 if (!args) SWIG_fail;
22551 swig_obj[0] = args;
22552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22555 }
22556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22557 result = (bool) ((arg1)->m_altDown);
22558 {
22559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22560 }
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22568 PyObject *resultobj = 0;
22569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22570 bool arg2 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 bool val2 ;
22574 int ecode2 = 0 ;
22575 PyObject *swig_obj[2] ;
22576
22577 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22579 if (!SWIG_IsOK(res1)) {
22580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22581 }
22582 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22583 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22584 if (!SWIG_IsOK(ecode2)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22586 }
22587 arg2 = static_cast< bool >(val2);
22588 if (arg1) (arg1)->m_metaDown = arg2;
22589
22590 resultobj = SWIG_Py_Void();
22591 return resultobj;
22592 fail:
22593 return NULL;
22594 }
22595
22596
22597 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22598 PyObject *resultobj = 0;
22599 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22600 bool result;
22601 void *argp1 = 0 ;
22602 int res1 = 0 ;
22603 PyObject *swig_obj[1] ;
22604
22605 if (!args) SWIG_fail;
22606 swig_obj[0] = args;
22607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22608 if (!SWIG_IsOK(res1)) {
22609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22610 }
22611 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22612 result = (bool) ((arg1)->m_metaDown);
22613 {
22614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22615 }
22616 return resultobj;
22617 fail:
22618 return NULL;
22619 }
22620
22621
22622 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22623 PyObject *resultobj = 0;
22624 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22625 bool arg2 ;
22626 void *argp1 = 0 ;
22627 int res1 = 0 ;
22628 bool val2 ;
22629 int ecode2 = 0 ;
22630 PyObject *swig_obj[2] ;
22631
22632 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22634 if (!SWIG_IsOK(res1)) {
22635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22636 }
22637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22638 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22639 if (!SWIG_IsOK(ecode2)) {
22640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22641 }
22642 arg2 = static_cast< bool >(val2);
22643 if (arg1) (arg1)->m_scanCode = arg2;
22644
22645 resultobj = SWIG_Py_Void();
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22653 PyObject *resultobj = 0;
22654 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22655 bool result;
22656 void *argp1 = 0 ;
22657 int res1 = 0 ;
22658 PyObject *swig_obj[1] ;
22659
22660 if (!args) SWIG_fail;
22661 swig_obj[0] = args;
22662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22663 if (!SWIG_IsOK(res1)) {
22664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22665 }
22666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22667 result = (bool) ((arg1)->m_scanCode);
22668 {
22669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22670 }
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 unsigned int arg2 ;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 unsigned int val2 ;
22684 int ecode2 = 0 ;
22685 PyObject *swig_obj[2] ;
22686
22687 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22689 if (!SWIG_IsOK(res1)) {
22690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22691 }
22692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22693 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22694 if (!SWIG_IsOK(ecode2)) {
22695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22696 }
22697 arg2 = static_cast< unsigned int >(val2);
22698 if (arg1) (arg1)->m_rawCode = arg2;
22699
22700 resultobj = SWIG_Py_Void();
22701 return resultobj;
22702 fail:
22703 return NULL;
22704 }
22705
22706
22707 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22708 PyObject *resultobj = 0;
22709 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22710 unsigned int result;
22711 void *argp1 = 0 ;
22712 int res1 = 0 ;
22713 PyObject *swig_obj[1] ;
22714
22715 if (!args) SWIG_fail;
22716 swig_obj[0] = args;
22717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22718 if (!SWIG_IsOK(res1)) {
22719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22720 }
22721 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22722 result = (unsigned int) ((arg1)->m_rawCode);
22723 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 PyObject *resultobj = 0;
22732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22733 unsigned int arg2 ;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 unsigned int val2 ;
22737 int ecode2 = 0 ;
22738 PyObject *swig_obj[2] ;
22739
22740 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22742 if (!SWIG_IsOK(res1)) {
22743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22744 }
22745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22746 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22747 if (!SWIG_IsOK(ecode2)) {
22748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22749 }
22750 arg2 = static_cast< unsigned int >(val2);
22751 if (arg1) (arg1)->m_rawFlags = arg2;
22752
22753 resultobj = SWIG_Py_Void();
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22761 PyObject *resultobj = 0;
22762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22763 unsigned int result;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 PyObject *swig_obj[1] ;
22767
22768 if (!args) SWIG_fail;
22769 swig_obj[0] = args;
22770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22771 if (!SWIG_IsOK(res1)) {
22772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22773 }
22774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22775 result = (unsigned int) ((arg1)->m_rawFlags);
22776 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *obj;
22785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22786 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22787 return SWIG_Py_Void();
22788 }
22789
22790 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 return SWIG_Python_InitShadowInstance(args);
22792 }
22793
22794 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22795 PyObject *resultobj = 0;
22796 wxSize const &arg1_defvalue = wxDefaultSize ;
22797 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22798 int arg2 = (int) 0 ;
22799 wxSizeEvent *result = 0 ;
22800 wxSize temp1 ;
22801 int val2 ;
22802 int ecode2 = 0 ;
22803 PyObject * obj0 = 0 ;
22804 PyObject * obj1 = 0 ;
22805 char * kwnames[] = {
22806 (char *) "sz",(char *) "winid", NULL
22807 };
22808
22809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22810 if (obj0) {
22811 {
22812 arg1 = &temp1;
22813 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22814 }
22815 }
22816 if (obj1) {
22817 ecode2 = SWIG_AsVal_int(obj1, &val2);
22818 if (!SWIG_IsOK(ecode2)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22820 }
22821 arg2 = static_cast< int >(val2);
22822 }
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22826 wxPyEndAllowThreads(__tstate);
22827 if (PyErr_Occurred()) SWIG_fail;
22828 }
22829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22830 return resultobj;
22831 fail:
22832 return NULL;
22833 }
22834
22835
22836 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22837 PyObject *resultobj = 0;
22838 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22839 wxSize result;
22840 void *argp1 = 0 ;
22841 int res1 = 0 ;
22842 PyObject *swig_obj[1] ;
22843
22844 if (!args) SWIG_fail;
22845 swig_obj[0] = args;
22846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22847 if (!SWIG_IsOK(res1)) {
22848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22849 }
22850 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 result = ((wxSizeEvent const *)arg1)->GetSize();
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22865 PyObject *resultobj = 0;
22866 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22867 wxRect result;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 PyObject *swig_obj[1] ;
22871
22872 if (!args) SWIG_fail;
22873 swig_obj[0] = args;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22877 }
22878 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22879 {
22880 PyThreadState* __tstate = wxPyBeginAllowThreads();
22881 result = ((wxSizeEvent const *)arg1)->GetRect();
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22886 return resultobj;
22887 fail:
22888 return NULL;
22889 }
22890
22891
22892 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22893 PyObject *resultobj = 0;
22894 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22895 wxRect arg2 ;
22896 void *argp1 = 0 ;
22897 int res1 = 0 ;
22898 void *argp2 ;
22899 int res2 = 0 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char * kwnames[] = {
22903 (char *) "self",(char *) "rect", NULL
22904 };
22905
22906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22912 {
22913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22914 if (!SWIG_IsOK(res2)) {
22915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22916 }
22917 if (!argp2) {
22918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22919 } else {
22920 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22921 arg2 = *temp;
22922 if (SWIG_IsNewObj(res2)) delete temp;
22923 }
22924 }
22925 {
22926 PyThreadState* __tstate = wxPyBeginAllowThreads();
22927 (arg1)->SetRect(arg2);
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 resultobj = SWIG_Py_Void();
22932 return resultobj;
22933 fail:
22934 return NULL;
22935 }
22936
22937
22938 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22939 PyObject *resultobj = 0;
22940 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22941 wxSize arg2 ;
22942 void *argp1 = 0 ;
22943 int res1 = 0 ;
22944 void *argp2 ;
22945 int res2 = 0 ;
22946 PyObject * obj0 = 0 ;
22947 PyObject * obj1 = 0 ;
22948 char * kwnames[] = {
22949 (char *) "self",(char *) "size", NULL
22950 };
22951
22952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22954 if (!SWIG_IsOK(res1)) {
22955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22956 }
22957 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22958 {
22959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22960 if (!SWIG_IsOK(res2)) {
22961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22962 }
22963 if (!argp2) {
22964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22965 } else {
22966 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22967 arg2 = *temp;
22968 if (SWIG_IsNewObj(res2)) delete temp;
22969 }
22970 }
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 wxSizeEvent_SetSize(arg1,arg2);
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 resultobj = SWIG_Py_Void();
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 PyObject *resultobj = 0;
22986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22987 wxSize *arg2 = (wxSize *) 0 ;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 void *argp2 = 0 ;
22991 int res2 = 0 ;
22992 PyObject *swig_obj[2] ;
22993
22994 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22996 if (!SWIG_IsOK(res1)) {
22997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22998 }
22999 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23000 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23001 if (!SWIG_IsOK(res2)) {
23002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23003 }
23004 arg2 = reinterpret_cast< wxSize * >(argp2);
23005 if (arg1) (arg1)->m_size = *arg2;
23006
23007 resultobj = SWIG_Py_Void();
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23017 wxSize *result = 0 ;
23018 void *argp1 = 0 ;
23019 int res1 = 0 ;
23020 PyObject *swig_obj[1] ;
23021
23022 if (!args) SWIG_fail;
23023 swig_obj[0] = args;
23024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23025 if (!SWIG_IsOK(res1)) {
23026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23027 }
23028 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23029 result = (wxSize *)& ((arg1)->m_size);
23030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23040 wxRect *arg2 = (wxRect *) 0 ;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 void *argp2 = 0 ;
23044 int res2 = 0 ;
23045 PyObject *swig_obj[2] ;
23046
23047 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23049 if (!SWIG_IsOK(res1)) {
23050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23051 }
23052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23053 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23054 if (!SWIG_IsOK(res2)) {
23055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23056 }
23057 arg2 = reinterpret_cast< wxRect * >(argp2);
23058 if (arg1) (arg1)->m_rect = *arg2;
23059
23060 resultobj = SWIG_Py_Void();
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068 PyObject *resultobj = 0;
23069 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23070 wxRect *result = 0 ;
23071 void *argp1 = 0 ;
23072 int res1 = 0 ;
23073 PyObject *swig_obj[1] ;
23074
23075 if (!args) SWIG_fail;
23076 swig_obj[0] = args;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23080 }
23081 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23082 result = (wxRect *)& ((arg1)->m_rect);
23083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23091 PyObject *obj;
23092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23093 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23094 return SWIG_Py_Void();
23095 }
23096
23097 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 return SWIG_Python_InitShadowInstance(args);
23099 }
23100
23101 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23102 PyObject *resultobj = 0;
23103 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23104 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23105 int arg2 = (int) 0 ;
23106 wxMoveEvent *result = 0 ;
23107 wxPoint temp1 ;
23108 int val2 ;
23109 int ecode2 = 0 ;
23110 PyObject * obj0 = 0 ;
23111 PyObject * obj1 = 0 ;
23112 char * kwnames[] = {
23113 (char *) "pos",(char *) "winid", NULL
23114 };
23115
23116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23117 if (obj0) {
23118 {
23119 arg1 = &temp1;
23120 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23121 }
23122 }
23123 if (obj1) {
23124 ecode2 = SWIG_AsVal_int(obj1, &val2);
23125 if (!SWIG_IsOK(ecode2)) {
23126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23127 }
23128 arg2 = static_cast< int >(val2);
23129 }
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23144 PyObject *resultobj = 0;
23145 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23146 wxPoint result;
23147 void *argp1 = 0 ;
23148 int res1 = 0 ;
23149 PyObject *swig_obj[1] ;
23150
23151 if (!args) SWIG_fail;
23152 swig_obj[0] = args;
23153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23156 }
23157 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = ((wxMoveEvent const *)arg1)->GetPosition();
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23174 wxRect result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = ((wxMoveEvent const *)arg1)->GetRect();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23200 PyObject *resultobj = 0;
23201 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23202 wxRect *arg2 = 0 ;
23203 void *argp1 = 0 ;
23204 int res1 = 0 ;
23205 wxRect temp2 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char * kwnames[] = {
23209 (char *) "self",(char *) "rect", NULL
23210 };
23211
23212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23214 if (!SWIG_IsOK(res1)) {
23215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23216 }
23217 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23218 {
23219 arg2 = &temp2;
23220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23221 }
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 (arg1)->SetRect((wxRect const &)*arg2);
23225 wxPyEndAllowThreads(__tstate);
23226 if (PyErr_Occurred()) SWIG_fail;
23227 }
23228 resultobj = SWIG_Py_Void();
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23236 PyObject *resultobj = 0;
23237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23238 wxPoint *arg2 = 0 ;
23239 void *argp1 = 0 ;
23240 int res1 = 0 ;
23241 wxPoint temp2 ;
23242 PyObject * obj0 = 0 ;
23243 PyObject * obj1 = 0 ;
23244 char * kwnames[] = {
23245 (char *) "self",(char *) "pos", NULL
23246 };
23247
23248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23252 }
23253 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23254 {
23255 arg2 = &temp2;
23256 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 (arg1)->SetPosition((wxPoint const &)*arg2);
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 resultobj = SWIG_Py_Void();
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23272 PyObject *obj;
23273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23274 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23275 return SWIG_Py_Void();
23276 }
23277
23278 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 return SWIG_Python_InitShadowInstance(args);
23280 }
23281
23282 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23283 PyObject *resultobj = 0;
23284 int arg1 = (int) 0 ;
23285 wxPaintEvent *result = 0 ;
23286 int val1 ;
23287 int ecode1 = 0 ;
23288 PyObject * obj0 = 0 ;
23289 char * kwnames[] = {
23290 (char *) "Id", NULL
23291 };
23292
23293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23294 if (obj0) {
23295 ecode1 = SWIG_AsVal_int(obj0, &val1);
23296 if (!SWIG_IsOK(ecode1)) {
23297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23298 }
23299 arg1 = static_cast< int >(val1);
23300 }
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *obj;
23316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23318 return SWIG_Py_Void();
23319 }
23320
23321 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 return SWIG_Python_InitShadowInstance(args);
23323 }
23324
23325 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj = 0;
23327 int arg1 = (int) 0 ;
23328 wxNcPaintEvent *result = 0 ;
23329 int val1 ;
23330 int ecode1 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "winid", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23337 if (obj0) {
23338 ecode1 = SWIG_AsVal_int(obj0, &val1);
23339 if (!SWIG_IsOK(ecode1)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23341 }
23342 arg1 = static_cast< int >(val1);
23343 }
23344 {
23345 PyThreadState* __tstate = wxPyBeginAllowThreads();
23346 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23358 PyObject *obj;
23359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23360 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23361 return SWIG_Py_Void();
23362 }
23363
23364 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23365 return SWIG_Python_InitShadowInstance(args);
23366 }
23367
23368 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj = 0;
23370 int arg1 = (int) 0 ;
23371 wxDC *arg2 = (wxDC *) NULL ;
23372 wxEraseEvent *result = 0 ;
23373 int val1 ;
23374 int ecode1 = 0 ;
23375 void *argp2 = 0 ;
23376 int res2 = 0 ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 char * kwnames[] = {
23380 (char *) "Id",(char *) "dc", NULL
23381 };
23382
23383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23384 if (obj0) {
23385 ecode1 = SWIG_AsVal_int(obj0, &val1);
23386 if (!SWIG_IsOK(ecode1)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23388 }
23389 arg1 = static_cast< int >(val1);
23390 }
23391 if (obj1) {
23392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23393 if (!SWIG_IsOK(res2)) {
23394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23395 }
23396 arg2 = reinterpret_cast< wxDC * >(argp2);
23397 }
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23414 wxDC *result = 0 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 PyObject *swig_obj[1] ;
23418
23419 if (!args) SWIG_fail;
23420 swig_obj[0] = args;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = wxPyMake_wxObject(result, (bool)0);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *obj;
23443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23444 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23445 return SWIG_Py_Void();
23446 }
23447
23448 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23449 return SWIG_Python_InitShadowInstance(args);
23450 }
23451
23452 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj = 0;
23454 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23455 int arg2 = (int) 0 ;
23456 wxFocusEvent *result = 0 ;
23457 int val1 ;
23458 int ecode1 = 0 ;
23459 int val2 ;
23460 int ecode2 = 0 ;
23461 PyObject * obj0 = 0 ;
23462 PyObject * obj1 = 0 ;
23463 char * kwnames[] = {
23464 (char *) "type",(char *) "winid", NULL
23465 };
23466
23467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23468 if (obj0) {
23469 ecode1 = SWIG_AsVal_int(obj0, &val1);
23470 if (!SWIG_IsOK(ecode1)) {
23471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23472 }
23473 arg1 = static_cast< wxEventType >(val1);
23474 }
23475 if (obj1) {
23476 ecode2 = SWIG_AsVal_int(obj1, &val2);
23477 if (!SWIG_IsOK(ecode2)) {
23478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23479 }
23480 arg2 = static_cast< int >(val2);
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23489 return resultobj;
23490 fail:
23491 return NULL;
23492 }
23493
23494
23495 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23496 PyObject *resultobj = 0;
23497 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23498 wxWindow *result = 0 ;
23499 void *argp1 = 0 ;
23500 int res1 = 0 ;
23501 PyObject *swig_obj[1] ;
23502
23503 if (!args) SWIG_fail;
23504 swig_obj[0] = args;
23505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23506 if (!SWIG_IsOK(res1)) {
23507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23508 }
23509 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 {
23517 resultobj = wxPyMake_wxObject(result, (bool)0);
23518 }
23519 return resultobj;
23520 fail:
23521 return NULL;
23522 }
23523
23524
23525 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23526 PyObject *resultobj = 0;
23527 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23528 wxWindow *arg2 = (wxWindow *) 0 ;
23529 void *argp1 = 0 ;
23530 int res1 = 0 ;
23531 void *argp2 = 0 ;
23532 int res2 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char * kwnames[] = {
23536 (char *) "self",(char *) "win", NULL
23537 };
23538
23539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23541 if (!SWIG_IsOK(res1)) {
23542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23543 }
23544 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23546 if (!SWIG_IsOK(res2)) {
23547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23548 }
23549 arg2 = reinterpret_cast< wxWindow * >(argp2);
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 (arg1)->SetWindow(arg2);
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 resultobj = SWIG_Py_Void();
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23564 PyObject *obj;
23565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23566 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23567 return SWIG_Py_Void();
23568 }
23569
23570 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 return SWIG_Python_InitShadowInstance(args);
23572 }
23573
23574 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj = 0;
23576 wxWindow *arg1 = (wxWindow *) NULL ;
23577 wxChildFocusEvent *result = 0 ;
23578 void *argp1 = 0 ;
23579 int res1 = 0 ;
23580 PyObject * obj0 = 0 ;
23581 char * kwnames[] = {
23582 (char *) "win", NULL
23583 };
23584
23585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23586 if (obj0) {
23587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23590 }
23591 arg1 = reinterpret_cast< wxWindow * >(argp1);
23592 }
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23596 wxPyEndAllowThreads(__tstate);
23597 if (PyErr_Occurred()) SWIG_fail;
23598 }
23599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23609 wxWindow *result = 0 ;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23619 }
23620 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 resultobj = wxPyMake_wxObject(result, (bool)0);
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23637 PyObject *obj;
23638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23639 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23640 return SWIG_Py_Void();
23641 }
23642
23643 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23644 return SWIG_Python_InitShadowInstance(args);
23645 }
23646
23647 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj = 0;
23649 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23650 bool arg2 = (bool) true ;
23651 int arg3 = (int) 0 ;
23652 wxActivateEvent *result = 0 ;
23653 int val1 ;
23654 int ecode1 = 0 ;
23655 bool val2 ;
23656 int ecode2 = 0 ;
23657 int val3 ;
23658 int ecode3 = 0 ;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 PyObject * obj2 = 0 ;
23662 char * kwnames[] = {
23663 (char *) "type",(char *) "active",(char *) "Id", NULL
23664 };
23665
23666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23667 if (obj0) {
23668 ecode1 = SWIG_AsVal_int(obj0, &val1);
23669 if (!SWIG_IsOK(ecode1)) {
23670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23671 }
23672 arg1 = static_cast< wxEventType >(val1);
23673 }
23674 if (obj1) {
23675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23676 if (!SWIG_IsOK(ecode2)) {
23677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23678 }
23679 arg2 = static_cast< bool >(val2);
23680 }
23681 if (obj2) {
23682 ecode3 = SWIG_AsVal_int(obj2, &val3);
23683 if (!SWIG_IsOK(ecode3)) {
23684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23685 }
23686 arg3 = static_cast< int >(val3);
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23704 bool result;
23705 void *argp1 = 0 ;
23706 int res1 = 0 ;
23707 PyObject *swig_obj[1] ;
23708
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23714 }
23715 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 {
23723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *obj;
23733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23734 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23735 return SWIG_Py_Void();
23736 }
23737
23738 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 return SWIG_Python_InitShadowInstance(args);
23740 }
23741
23742 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 int arg1 = (int) 0 ;
23745 wxInitDialogEvent *result = 0 ;
23746 int val1 ;
23747 int ecode1 = 0 ;
23748 PyObject * obj0 = 0 ;
23749 char * kwnames[] = {
23750 (char *) "Id", NULL
23751 };
23752
23753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23754 if (obj0) {
23755 ecode1 = SWIG_AsVal_int(obj0, &val1);
23756 if (!SWIG_IsOK(ecode1)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23758 }
23759 arg1 = static_cast< int >(val1);
23760 }
23761 {
23762 PyThreadState* __tstate = wxPyBeginAllowThreads();
23763 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23764 wxPyEndAllowThreads(__tstate);
23765 if (PyErr_Occurred()) SWIG_fail;
23766 }
23767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23768 return resultobj;
23769 fail:
23770 return NULL;
23771 }
23772
23773
23774 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23775 PyObject *obj;
23776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23777 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23778 return SWIG_Py_Void();
23779 }
23780
23781 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 return SWIG_Python_InitShadowInstance(args);
23783 }
23784
23785 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj = 0;
23787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23788 int arg2 = (int) 0 ;
23789 wxMenu *arg3 = (wxMenu *) NULL ;
23790 wxMenuEvent *result = 0 ;
23791 int val1 ;
23792 int ecode1 = 0 ;
23793 int val2 ;
23794 int ecode2 = 0 ;
23795 void *argp3 = 0 ;
23796 int res3 = 0 ;
23797 PyObject * obj0 = 0 ;
23798 PyObject * obj1 = 0 ;
23799 PyObject * obj2 = 0 ;
23800 char * kwnames[] = {
23801 (char *) "type",(char *) "winid",(char *) "menu", NULL
23802 };
23803
23804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23805 if (obj0) {
23806 ecode1 = SWIG_AsVal_int(obj0, &val1);
23807 if (!SWIG_IsOK(ecode1)) {
23808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23809 }
23810 arg1 = static_cast< wxEventType >(val1);
23811 }
23812 if (obj1) {
23813 ecode2 = SWIG_AsVal_int(obj1, &val2);
23814 if (!SWIG_IsOK(ecode2)) {
23815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23816 }
23817 arg2 = static_cast< int >(val2);
23818 }
23819 if (obj2) {
23820 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23821 if (!SWIG_IsOK(res3)) {
23822 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23823 }
23824 arg3 = reinterpret_cast< wxMenu * >(argp3);
23825 }
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23870 bool result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 {
23889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23890 }
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23898 PyObject *resultobj = 0;
23899 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23900 wxMenu *result = 0 ;
23901 void *argp1 = 0 ;
23902 int res1 = 0 ;
23903 PyObject *swig_obj[1] ;
23904
23905 if (!args) SWIG_fail;
23906 swig_obj[0] = args;
23907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23908 if (!SWIG_IsOK(res1)) {
23909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23910 }
23911 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23912 {
23913 PyThreadState* __tstate = wxPyBeginAllowThreads();
23914 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 {
23919 resultobj = wxPyMake_wxObject(result, (bool)0);
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23928 PyObject *obj;
23929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23930 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23931 return SWIG_Py_Void();
23932 }
23933
23934 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 return SWIG_Python_InitShadowInstance(args);
23936 }
23937
23938 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23939 PyObject *resultobj = 0;
23940 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23941 int arg2 = (int) 0 ;
23942 wxCloseEvent *result = 0 ;
23943 int val1 ;
23944 int ecode1 = 0 ;
23945 int val2 ;
23946 int ecode2 = 0 ;
23947 PyObject * obj0 = 0 ;
23948 PyObject * obj1 = 0 ;
23949 char * kwnames[] = {
23950 (char *) "type",(char *) "winid", NULL
23951 };
23952
23953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23954 if (obj0) {
23955 ecode1 = SWIG_AsVal_int(obj0, &val1);
23956 if (!SWIG_IsOK(ecode1)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23958 }
23959 arg1 = static_cast< wxEventType >(val1);
23960 }
23961 if (obj1) {
23962 ecode2 = SWIG_AsVal_int(obj1, &val2);
23963 if (!SWIG_IsOK(ecode2)) {
23964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23965 }
23966 arg2 = static_cast< int >(val2);
23967 }
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23971 wxPyEndAllowThreads(__tstate);
23972 if (PyErr_Occurred()) SWIG_fail;
23973 }
23974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23975 return resultobj;
23976 fail:
23977 return NULL;
23978 }
23979
23980
23981 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23982 PyObject *resultobj = 0;
23983 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23984 bool arg2 ;
23985 void *argp1 = 0 ;
23986 int res1 = 0 ;
23987 bool val2 ;
23988 int ecode2 = 0 ;
23989 PyObject * obj0 = 0 ;
23990 PyObject * obj1 = 0 ;
23991 char * kwnames[] = {
23992 (char *) "self",(char *) "logOff", NULL
23993 };
23994
23995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23997 if (!SWIG_IsOK(res1)) {
23998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
23999 }
24000 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24002 if (!SWIG_IsOK(ecode2)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24004 }
24005 arg2 = static_cast< bool >(val2);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 (arg1)->SetLoggingOff(arg2);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_Py_Void();
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *resultobj = 0;
24021 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24022 bool result;
24023 void *argp1 = 0 ;
24024 int res1 = 0 ;
24025 PyObject *swig_obj[1] ;
24026
24027 if (!args) SWIG_fail;
24028 swig_obj[0] = args;
24029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24032 }
24033 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 {
24041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24042 }
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj = 0;
24051 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24052 bool arg2 = (bool) true ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 bool val2 ;
24056 int ecode2 = 0 ;
24057 PyObject * obj0 = 0 ;
24058 PyObject * obj1 = 0 ;
24059 char * kwnames[] = {
24060 (char *) "self",(char *) "veto", NULL
24061 };
24062
24063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24067 }
24068 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24069 if (obj1) {
24070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24071 if (!SWIG_IsOK(ecode2)) {
24072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24073 }
24074 arg2 = static_cast< bool >(val2);
24075 }
24076 {
24077 PyThreadState* __tstate = wxPyBeginAllowThreads();
24078 (arg1)->Veto(arg2);
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 resultobj = SWIG_Py_Void();
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24090 PyObject *resultobj = 0;
24091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24092 bool result;
24093 void *argp1 = 0 ;
24094 int res1 = 0 ;
24095 PyObject *swig_obj[1] ;
24096
24097 if (!args) SWIG_fail;
24098 swig_obj[0] = args;
24099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24100 if (!SWIG_IsOK(res1)) {
24101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24102 }
24103 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj = 0;
24121 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24122 bool arg2 ;
24123 void *argp1 = 0 ;
24124 int res1 = 0 ;
24125 bool val2 ;
24126 int ecode2 = 0 ;
24127 PyObject * obj0 = 0 ;
24128 PyObject * obj1 = 0 ;
24129 char * kwnames[] = {
24130 (char *) "self",(char *) "canVeto", NULL
24131 };
24132
24133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24137 }
24138 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24139 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24140 if (!SWIG_IsOK(ecode2)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24142 }
24143 arg2 = static_cast< bool >(val2);
24144 {
24145 PyThreadState* __tstate = wxPyBeginAllowThreads();
24146 (arg1)->SetCanVeto(arg2);
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 resultobj = SWIG_Py_Void();
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *resultobj = 0;
24159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24160 bool result;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 PyObject *swig_obj[1] ;
24164
24165 if (!args) SWIG_fail;
24166 swig_obj[0] = args;
24167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24168 if (!SWIG_IsOK(res1)) {
24169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24170 }
24171 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 {
24179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24180 }
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24188 PyObject *obj;
24189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24190 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24191 return SWIG_Py_Void();
24192 }
24193
24194 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24195 return SWIG_Python_InitShadowInstance(args);
24196 }
24197
24198 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj = 0;
24200 int arg1 = (int) 0 ;
24201 bool arg2 = (bool) false ;
24202 wxShowEvent *result = 0 ;
24203 int val1 ;
24204 int ecode1 = 0 ;
24205 bool val2 ;
24206 int ecode2 = 0 ;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char * kwnames[] = {
24210 (char *) "winid",(char *) "show", NULL
24211 };
24212
24213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24214 if (obj0) {
24215 ecode1 = SWIG_AsVal_int(obj0, &val1);
24216 if (!SWIG_IsOK(ecode1)) {
24217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24218 }
24219 arg1 = static_cast< int >(val1);
24220 }
24221 if (obj1) {
24222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24223 if (!SWIG_IsOK(ecode2)) {
24224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24225 }
24226 arg2 = static_cast< bool >(val2);
24227 }
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24242 PyObject *resultobj = 0;
24243 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24244 bool arg2 ;
24245 void *argp1 = 0 ;
24246 int res1 = 0 ;
24247 bool val2 ;
24248 int ecode2 = 0 ;
24249 PyObject * obj0 = 0 ;
24250 PyObject * obj1 = 0 ;
24251 char * kwnames[] = {
24252 (char *) "self",(char *) "show", NULL
24253 };
24254
24255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24257 if (!SWIG_IsOK(res1)) {
24258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24259 }
24260 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24262 if (!SWIG_IsOK(ecode2)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24264 }
24265 arg2 = static_cast< bool >(val2);
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 (arg1)->SetShow(arg2);
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 resultobj = SWIG_Py_Void();
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *resultobj = 0;
24281 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24282 bool result;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 PyObject *swig_obj[1] ;
24286
24287 if (!args) SWIG_fail;
24288 swig_obj[0] = args;
24289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24290 if (!SWIG_IsOK(res1)) {
24291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24292 }
24293 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24294 {
24295 PyThreadState* __tstate = wxPyBeginAllowThreads();
24296 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24297 wxPyEndAllowThreads(__tstate);
24298 if (PyErr_Occurred()) SWIG_fail;
24299 }
24300 {
24301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24302 }
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *obj;
24311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24312 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24313 return SWIG_Py_Void();
24314 }
24315
24316 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24317 return SWIG_Python_InitShadowInstance(args);
24318 }
24319
24320 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj = 0;
24322 int arg1 = (int) 0 ;
24323 bool arg2 = (bool) true ;
24324 wxIconizeEvent *result = 0 ;
24325 int val1 ;
24326 int ecode1 = 0 ;
24327 bool val2 ;
24328 int ecode2 = 0 ;
24329 PyObject * obj0 = 0 ;
24330 PyObject * obj1 = 0 ;
24331 char * kwnames[] = {
24332 (char *) "id",(char *) "iconized", NULL
24333 };
24334
24335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24336 if (obj0) {
24337 ecode1 = SWIG_AsVal_int(obj0, &val1);
24338 if (!SWIG_IsOK(ecode1)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24340 }
24341 arg1 = static_cast< int >(val1);
24342 }
24343 if (obj1) {
24344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24345 if (!SWIG_IsOK(ecode2)) {
24346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24347 }
24348 arg2 = static_cast< bool >(val2);
24349 }
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24364 PyObject *resultobj = 0;
24365 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24366 bool result;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 PyObject *swig_obj[1] ;
24370
24371 if (!args) SWIG_fail;
24372 swig_obj[0] = args;
24373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24374 if (!SWIG_IsOK(res1)) {
24375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24376 }
24377 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 result = (bool)(arg1)->Iconized();
24381 wxPyEndAllowThreads(__tstate);
24382 if (PyErr_Occurred()) SWIG_fail;
24383 }
24384 {
24385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24386 }
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *obj;
24395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24396 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24397 return SWIG_Py_Void();
24398 }
24399
24400 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24401 return SWIG_Python_InitShadowInstance(args);
24402 }
24403
24404 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj = 0;
24406 int arg1 = (int) 0 ;
24407 wxMaximizeEvent *result = 0 ;
24408 int val1 ;
24409 int ecode1 = 0 ;
24410 PyObject * obj0 = 0 ;
24411 char * kwnames[] = {
24412 (char *) "id", NULL
24413 };
24414
24415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24416 if (obj0) {
24417 ecode1 = SWIG_AsVal_int(obj0, &val1);
24418 if (!SWIG_IsOK(ecode1)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24420 }
24421 arg1 = static_cast< int >(val1);
24422 }
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *obj;
24438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24440 return SWIG_Py_Void();
24441 }
24442
24443 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24444 return SWIG_Python_InitShadowInstance(args);
24445 }
24446
24447 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448 PyObject *resultobj = 0;
24449 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24450 wxPoint result;
24451 void *argp1 = 0 ;
24452 int res1 = 0 ;
24453 PyObject *swig_obj[1] ;
24454
24455 if (!args) SWIG_fail;
24456 swig_obj[0] = args;
24457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24458 if (!SWIG_IsOK(res1)) {
24459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24460 }
24461 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = (arg1)->GetPosition();
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = (int)(arg1)->GetNumberOfFiles();
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_From_int(static_cast< int >(result));
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24506 PyObject *result = 0 ;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 PyObject *swig_obj[1] ;
24510
24511 if (!args) SWIG_fail;
24512 swig_obj[0] = args;
24513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24516 }
24517 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = result;
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *obj;
24533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24534 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24535 return SWIG_Py_Void();
24536 }
24537
24538 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = 0;
24540 int arg1 = (int) 0 ;
24541 wxUpdateUIEvent *result = 0 ;
24542 int val1 ;
24543 int ecode1 = 0 ;
24544 PyObject * obj0 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "commandId", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24550 if (obj0) {
24551 ecode1 = SWIG_AsVal_int(obj0, &val1);
24552 if (!SWIG_IsOK(ecode1)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24554 }
24555 arg1 = static_cast< int >(val1);
24556 }
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571 PyObject *resultobj = 0;
24572 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24573 bool result;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 PyObject *swig_obj[1] ;
24577
24578 if (!args) SWIG_fail;
24579 swig_obj[0] = args;
24580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24581 if (!SWIG_IsOK(res1)) {
24582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24583 }
24584 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 {
24592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24601 PyObject *resultobj = 0;
24602 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24603 bool result;
24604 void *argp1 = 0 ;
24605 int res1 = 0 ;
24606 PyObject *swig_obj[1] ;
24607
24608 if (!args) SWIG_fail;
24609 swig_obj[0] = args;
24610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24611 if (!SWIG_IsOK(res1)) {
24612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24613 }
24614 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 {
24622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24623 }
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *resultobj = 0;
24632 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24633 bool result;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 PyObject *swig_obj[1] ;
24637
24638 if (!args) SWIG_fail;
24639 swig_obj[0] = args;
24640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24643 }
24644 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 {
24652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24653 }
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24661 PyObject *resultobj = 0;
24662 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24663 wxString result;
24664 void *argp1 = 0 ;
24665 int res1 = 0 ;
24666 PyObject *swig_obj[1] ;
24667
24668 if (!args) SWIG_fail;
24669 swig_obj[0] = args;
24670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24671 if (!SWIG_IsOK(res1)) {
24672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24673 }
24674 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 #if wxUSE_UNICODE
24683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24684 #else
24685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24686 #endif
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *resultobj = 0;
24696 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24697 bool result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 PyObject *swig_obj[1] ;
24701
24702 if (!args) SWIG_fail;
24703 swig_obj[0] = args;
24704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24707 }
24708 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24757 bool result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24777 }
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 PyObject *resultobj = 0;
24786 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24787 bool result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 PyObject *swig_obj[1] ;
24791
24792 if (!args) SWIG_fail;
24793 swig_obj[0] = args;
24794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 {
24806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24807 }
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24817 bool arg2 ;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 bool val2 ;
24821 int ecode2 = 0 ;
24822 PyObject * obj0 = 0 ;
24823 PyObject * obj1 = 0 ;
24824 char * kwnames[] = {
24825 (char *) "self",(char *) "check", NULL
24826 };
24827
24828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24830 if (!SWIG_IsOK(res1)) {
24831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24832 }
24833 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24835 if (!SWIG_IsOK(ecode2)) {
24836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24837 }
24838 arg2 = static_cast< bool >(val2);
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 (arg1)->Check(arg2);
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_Py_Void();
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj = 0;
24854 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24855 bool arg2 ;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 bool val2 ;
24859 int ecode2 = 0 ;
24860 PyObject * obj0 = 0 ;
24861 PyObject * obj1 = 0 ;
24862 char * kwnames[] = {
24863 (char *) "self",(char *) "enable", NULL
24864 };
24865
24866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24868 if (!SWIG_IsOK(res1)) {
24869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24870 }
24871 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24873 if (!SWIG_IsOK(ecode2)) {
24874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24875 }
24876 arg2 = static_cast< bool >(val2);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 (arg1)->Enable(arg2);
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_Py_Void();
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj = 0;
24892 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24893 bool arg2 ;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 bool val2 ;
24897 int ecode2 = 0 ;
24898 PyObject * obj0 = 0 ;
24899 PyObject * obj1 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "self",(char *) "show", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24908 }
24909 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24911 if (!SWIG_IsOK(ecode2)) {
24912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24913 }
24914 arg2 = static_cast< bool >(val2);
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 (arg1)->Show(arg2);
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_Py_Void();
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24931 wxString *arg2 = 0 ;
24932 void *argp1 = 0 ;
24933 int res1 = 0 ;
24934 bool temp2 = false ;
24935 PyObject * obj0 = 0 ;
24936 PyObject * obj1 = 0 ;
24937 char * kwnames[] = {
24938 (char *) "self",(char *) "text", NULL
24939 };
24940
24941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24943 if (!SWIG_IsOK(res1)) {
24944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24945 }
24946 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24947 {
24948 arg2 = wxString_in_helper(obj1);
24949 if (arg2 == NULL) SWIG_fail;
24950 temp2 = true;
24951 }
24952 {
24953 PyThreadState* __tstate = wxPyBeginAllowThreads();
24954 (arg1)->SetText((wxString const &)*arg2);
24955 wxPyEndAllowThreads(__tstate);
24956 if (PyErr_Occurred()) SWIG_fail;
24957 }
24958 resultobj = SWIG_Py_Void();
24959 {
24960 if (temp2)
24961 delete arg2;
24962 }
24963 return resultobj;
24964 fail:
24965 {
24966 if (temp2)
24967 delete arg2;
24968 }
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj = 0;
24975 long arg1 ;
24976 long val1 ;
24977 int ecode1 = 0 ;
24978 PyObject * obj0 = 0 ;
24979 char * kwnames[] = {
24980 (char *) "updateInterval", NULL
24981 };
24982
24983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24984 ecode1 = SWIG_AsVal_long(obj0, &val1);
24985 if (!SWIG_IsOK(ecode1)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24987 }
24988 arg1 = static_cast< long >(val1);
24989 {
24990 PyThreadState* __tstate = wxPyBeginAllowThreads();
24991 wxUpdateUIEvent::SetUpdateInterval(arg1);
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 resultobj = SWIG_Py_Void();
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25003 PyObject *resultobj = 0;
25004 long result;
25005
25006 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 resultobj = SWIG_From_long(static_cast< long >(result));
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxWindow *arg1 = (wxWindow *) 0 ;
25023 bool result;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 PyObject * obj0 = 0 ;
25027 char * kwnames[] = {
25028 (char *) "win", NULL
25029 };
25030
25031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25033 if (!SWIG_IsOK(res1)) {
25034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25035 }
25036 arg1 = reinterpret_cast< wxWindow * >(argp1);
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 {
25044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25045 }
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25053 PyObject *resultobj = 0;
25054
25055 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25056 {
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 wxUpdateUIEvent::ResetUpdateTime();
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 resultobj = SWIG_Py_Void();
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 wxUpdateUIMode arg1 ;
25072 int val1 ;
25073 int ecode1 = 0 ;
25074 PyObject * obj0 = 0 ;
25075 char * kwnames[] = {
25076 (char *) "mode", NULL
25077 };
25078
25079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25080 ecode1 = SWIG_AsVal_int(obj0, &val1);
25081 if (!SWIG_IsOK(ecode1)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25083 }
25084 arg1 = static_cast< wxUpdateUIMode >(val1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 wxUpdateUIEvent::SetMode(arg1);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxUpdateUIMode result;
25101
25102 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25103 {
25104 PyThreadState* __tstate = wxPyBeginAllowThreads();
25105 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 resultobj = SWIG_From_int(static_cast< int >(result));
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25117 PyObject *obj;
25118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25119 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25120 return SWIG_Py_Void();
25121 }
25122
25123 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 return SWIG_Python_InitShadowInstance(args);
25125 }
25126
25127 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25128 PyObject *resultobj = 0;
25129 wxSysColourChangedEvent *result = 0 ;
25130
25131 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25139 return resultobj;
25140 fail:
25141 return NULL;
25142 }
25143
25144
25145 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25146 PyObject *obj;
25147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25148 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25149 return SWIG_Py_Void();
25150 }
25151
25152 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25153 return SWIG_Python_InitShadowInstance(args);
25154 }
25155
25156 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25157 PyObject *resultobj = 0;
25158 int arg1 = (int) 0 ;
25159 wxWindow *arg2 = (wxWindow *) NULL ;
25160 wxMouseCaptureChangedEvent *result = 0 ;
25161 int val1 ;
25162 int ecode1 = 0 ;
25163 void *argp2 = 0 ;
25164 int res2 = 0 ;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "winid",(char *) "gainedCapture", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25172 if (obj0) {
25173 ecode1 = SWIG_AsVal_int(obj0, &val1);
25174 if (!SWIG_IsOK(ecode1)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25176 }
25177 arg1 = static_cast< int >(val1);
25178 }
25179 if (obj1) {
25180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25181 if (!SWIG_IsOK(res2)) {
25182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25183 }
25184 arg2 = reinterpret_cast< wxWindow * >(argp2);
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25202 wxWindow *result = 0 ;
25203 void *argp1 = 0 ;
25204 int res1 = 0 ;
25205 PyObject *swig_obj[1] ;
25206
25207 if (!args) SWIG_fail;
25208 swig_obj[0] = args;
25209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25210 if (!SWIG_IsOK(res1)) {
25211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25212 }
25213 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 {
25221 resultobj = wxPyMake_wxObject(result, (bool)0);
25222 }
25223 return resultobj;
25224 fail:
25225 return NULL;
25226 }
25227
25228
25229 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25230 PyObject *obj;
25231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25232 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25233 return SWIG_Py_Void();
25234 }
25235
25236 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25237 return SWIG_Python_InitShadowInstance(args);
25238 }
25239
25240 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *resultobj = 0;
25242 wxDisplayChangedEvent *result = 0 ;
25243
25244 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25252 return resultobj;
25253 fail:
25254 return NULL;
25255 }
25256
25257
25258 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25259 PyObject *obj;
25260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25261 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25262 return SWIG_Py_Void();
25263 }
25264
25265 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25266 return SWIG_Python_InitShadowInstance(args);
25267 }
25268
25269 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25270 PyObject *resultobj = 0;
25271 int arg1 = (int) 0 ;
25272 wxPaletteChangedEvent *result = 0 ;
25273 int val1 ;
25274 int ecode1 = 0 ;
25275 PyObject * obj0 = 0 ;
25276 char * kwnames[] = {
25277 (char *) "id", NULL
25278 };
25279
25280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25281 if (obj0) {
25282 ecode1 = SWIG_AsVal_int(obj0, &val1);
25283 if (!SWIG_IsOK(ecode1)) {
25284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25285 }
25286 arg1 = static_cast< int >(val1);
25287 }
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj = 0;
25303 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25304 wxWindow *arg2 = (wxWindow *) 0 ;
25305 void *argp1 = 0 ;
25306 int res1 = 0 ;
25307 void *argp2 = 0 ;
25308 int res2 = 0 ;
25309 PyObject * obj0 = 0 ;
25310 PyObject * obj1 = 0 ;
25311 char * kwnames[] = {
25312 (char *) "self",(char *) "win", NULL
25313 };
25314
25315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25319 }
25320 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25322 if (!SWIG_IsOK(res2)) {
25323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25324 }
25325 arg2 = reinterpret_cast< wxWindow * >(argp2);
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 (arg1)->SetChangedWindow(arg2);
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 resultobj = SWIG_Py_Void();
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25340 PyObject *resultobj = 0;
25341 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25342 wxWindow *result = 0 ;
25343 void *argp1 = 0 ;
25344 int res1 = 0 ;
25345 PyObject *swig_obj[1] ;
25346
25347 if (!args) SWIG_fail;
25348 swig_obj[0] = args;
25349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25350 if (!SWIG_IsOK(res1)) {
25351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25352 }
25353 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 result = (wxWindow *)(arg1)->GetChangedWindow();
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 {
25361 resultobj = wxPyMake_wxObject(result, (bool)0);
25362 }
25363 return resultobj;
25364 fail:
25365 return NULL;
25366 }
25367
25368
25369 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25370 PyObject *obj;
25371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25372 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25373 return SWIG_Py_Void();
25374 }
25375
25376 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377 return SWIG_Python_InitShadowInstance(args);
25378 }
25379
25380 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj = 0;
25382 int arg1 = (int) 0 ;
25383 wxQueryNewPaletteEvent *result = 0 ;
25384 int val1 ;
25385 int ecode1 = 0 ;
25386 PyObject * obj0 = 0 ;
25387 char * kwnames[] = {
25388 (char *) "winid", NULL
25389 };
25390
25391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25392 if (obj0) {
25393 ecode1 = SWIG_AsVal_int(obj0, &val1);
25394 if (!SWIG_IsOK(ecode1)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25396 }
25397 arg1 = static_cast< int >(val1);
25398 }
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj = 0;
25414 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25415 bool arg2 ;
25416 void *argp1 = 0 ;
25417 int res1 = 0 ;
25418 bool val2 ;
25419 int ecode2 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 PyObject * obj1 = 0 ;
25422 char * kwnames[] = {
25423 (char *) "self",(char *) "realized", NULL
25424 };
25425
25426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25428 if (!SWIG_IsOK(res1)) {
25429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25430 }
25431 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25433 if (!SWIG_IsOK(ecode2)) {
25434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25435 }
25436 arg2 = static_cast< bool >(val2);
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 (arg1)->SetPaletteRealized(arg2);
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_Py_Void();
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 PyObject *resultobj = 0;
25452 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25453 bool result;
25454 void *argp1 = 0 ;
25455 int res1 = 0 ;
25456 PyObject *swig_obj[1] ;
25457
25458 if (!args) SWIG_fail;
25459 swig_obj[0] = args;
25460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25463 }
25464 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 {
25472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *obj;
25482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25483 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25484 return SWIG_Py_Void();
25485 }
25486
25487 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 return SWIG_Python_InitShadowInstance(args);
25489 }
25490
25491 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25492 PyObject *resultobj = 0;
25493 wxNavigationKeyEvent *result = 0 ;
25494
25495 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25496 {
25497 PyThreadState* __tstate = wxPyBeginAllowThreads();
25498 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25503 return resultobj;
25504 fail:
25505 return NULL;
25506 }
25507
25508
25509 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 PyObject *resultobj = 0;
25511 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25512 bool result;
25513 void *argp1 = 0 ;
25514 int res1 = 0 ;
25515 PyObject *swig_obj[1] ;
25516
25517 if (!args) SWIG_fail;
25518 swig_obj[0] = args;
25519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25520 if (!SWIG_IsOK(res1)) {
25521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25522 }
25523 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25527 wxPyEndAllowThreads(__tstate);
25528 if (PyErr_Occurred()) SWIG_fail;
25529 }
25530 {
25531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25532 }
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = 0;
25541 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25542 bool arg2 ;
25543 void *argp1 = 0 ;
25544 int res1 = 0 ;
25545 bool val2 ;
25546 int ecode2 = 0 ;
25547 PyObject * obj0 = 0 ;
25548 PyObject * obj1 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "self",(char *) "forward", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25555 if (!SWIG_IsOK(res1)) {
25556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25557 }
25558 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25560 if (!SWIG_IsOK(ecode2)) {
25561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25562 }
25563 arg2 = static_cast< bool >(val2);
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 (arg1)->SetDirection(arg2);
25567 wxPyEndAllowThreads(__tstate);
25568 if (PyErr_Occurred()) SWIG_fail;
25569 }
25570 resultobj = SWIG_Py_Void();
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25578 PyObject *resultobj = 0;
25579 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25580 bool result;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 PyObject *swig_obj[1] ;
25584
25585 if (!args) SWIG_fail;
25586 swig_obj[0] = args;
25587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25588 if (!SWIG_IsOK(res1)) {
25589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25590 }
25591 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj = 0;
25609 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25610 bool arg2 ;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 bool val2 ;
25614 int ecode2 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 PyObject * obj1 = 0 ;
25617 char * kwnames[] = {
25618 (char *) "self",(char *) "ischange", NULL
25619 };
25620
25621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25623 if (!SWIG_IsOK(res1)) {
25624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25625 }
25626 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25627 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25628 if (!SWIG_IsOK(ecode2)) {
25629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25630 }
25631 arg2 = static_cast< bool >(val2);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 (arg1)->SetWindowChange(arg2);
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_Py_Void();
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25648 bool result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25658 }
25659 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj = 0;
25677 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25678 bool arg2 ;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool val2 ;
25682 int ecode2 = 0 ;
25683 PyObject * obj0 = 0 ;
25684 PyObject * obj1 = 0 ;
25685 char * kwnames[] = {
25686 (char *) "self",(char *) "bIs", NULL
25687 };
25688
25689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25691 if (!SWIG_IsOK(res1)) {
25692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25693 }
25694 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25696 if (!SWIG_IsOK(ecode2)) {
25697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25698 }
25699 arg2 = static_cast< bool >(val2);
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 (arg1)->SetFromTab(arg2);
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_Py_Void();
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj = 0;
25715 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25716 long arg2 ;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 long val2 ;
25720 int ecode2 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "flags", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25733 ecode2 = SWIG_AsVal_long(obj1, &val2);
25734 if (!SWIG_IsOK(ecode2)) {
25735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25736 }
25737 arg2 = static_cast< long >(val2);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 (arg1)->SetFlags(arg2);
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 resultobj = SWIG_Py_Void();
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25752 PyObject *resultobj = 0;
25753 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25754 wxWindow *result = 0 ;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 PyObject *swig_obj[1] ;
25758
25759 if (!args) SWIG_fail;
25760 swig_obj[0] = args;
25761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25764 }
25765 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 {
25773 resultobj = wxPyMake_wxObject(result, (bool)0);
25774 }
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj = 0;
25783 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25784 wxWindow *arg2 = (wxWindow *) 0 ;
25785 void *argp1 = 0 ;
25786 int res1 = 0 ;
25787 void *argp2 = 0 ;
25788 int res2 = 0 ;
25789 PyObject * obj0 = 0 ;
25790 PyObject * obj1 = 0 ;
25791 char * kwnames[] = {
25792 (char *) "self",(char *) "win", NULL
25793 };
25794
25795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25802 if (!SWIG_IsOK(res2)) {
25803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25804 }
25805 arg2 = reinterpret_cast< wxWindow * >(argp2);
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 (arg1)->SetCurrentFocus(arg2);
25809 wxPyEndAllowThreads(__tstate);
25810 if (PyErr_Occurred()) SWIG_fail;
25811 }
25812 resultobj = SWIG_Py_Void();
25813 return resultobj;
25814 fail:
25815 return NULL;
25816 }
25817
25818
25819 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25820 PyObject *obj;
25821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25822 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25823 return SWIG_Py_Void();
25824 }
25825
25826 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25827 return SWIG_Python_InitShadowInstance(args);
25828 }
25829
25830 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25831 PyObject *resultobj = 0;
25832 wxWindow *arg1 = (wxWindow *) NULL ;
25833 wxWindowCreateEvent *result = 0 ;
25834 void *argp1 = 0 ;
25835 int res1 = 0 ;
25836 PyObject * obj0 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "win", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25842 if (obj0) {
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25846 }
25847 arg1 = reinterpret_cast< wxWindow * >(argp1);
25848 }
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25863 PyObject *resultobj = 0;
25864 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25865 wxWindow *result = 0 ;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 PyObject *swig_obj[1] ;
25869
25870 if (!args) SWIG_fail;
25871 swig_obj[0] = args;
25872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25875 }
25876 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 resultobj = wxPyMake_wxObject(result, (bool)0);
25885 }
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25893 PyObject *obj;
25894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25895 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25896 return SWIG_Py_Void();
25897 }
25898
25899 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25900 return SWIG_Python_InitShadowInstance(args);
25901 }
25902
25903 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj = 0;
25905 wxWindow *arg1 = (wxWindow *) NULL ;
25906 wxWindowDestroyEvent *result = 0 ;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 PyObject * obj0 = 0 ;
25910 char * kwnames[] = {
25911 (char *) "win", NULL
25912 };
25913
25914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25915 if (obj0) {
25916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25917 if (!SWIG_IsOK(res1)) {
25918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25919 }
25920 arg1 = reinterpret_cast< wxWindow * >(argp1);
25921 }
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25938 wxWindow *result = 0 ;
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_wxWindowDestroyEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25948 }
25949 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = wxPyMake_wxObject(result, (bool)0);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *WindowDestroyEvent_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_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25969 return SWIG_Py_Void();
25970 }
25971
25972 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 return SWIG_Python_InitShadowInstance(args);
25974 }
25975
25976 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25977 PyObject *resultobj = 0;
25978 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25979 int arg2 = (int) 0 ;
25980 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25981 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25982 wxContextMenuEvent *result = 0 ;
25983 int val1 ;
25984 int ecode1 = 0 ;
25985 int val2 ;
25986 int ecode2 = 0 ;
25987 wxPoint temp3 ;
25988 PyObject * obj0 = 0 ;
25989 PyObject * obj1 = 0 ;
25990 PyObject * obj2 = 0 ;
25991 char * kwnames[] = {
25992 (char *) "type",(char *) "winid",(char *) "pt", NULL
25993 };
25994
25995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25996 if (obj0) {
25997 ecode1 = SWIG_AsVal_int(obj0, &val1);
25998 if (!SWIG_IsOK(ecode1)) {
25999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26000 }
26001 arg1 = static_cast< wxEventType >(val1);
26002 }
26003 if (obj1) {
26004 ecode2 = SWIG_AsVal_int(obj1, &val2);
26005 if (!SWIG_IsOK(ecode2)) {
26006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26007 }
26008 arg2 = static_cast< int >(val2);
26009 }
26010 if (obj2) {
26011 {
26012 arg3 = &temp3;
26013 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26014 }
26015 }
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26030 PyObject *resultobj = 0;
26031 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26032 wxPoint *result = 0 ;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 PyObject *swig_obj[1] ;
26036
26037 if (!args) SWIG_fail;
26038 swig_obj[0] = args;
26039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26042 }
26043 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 {
26047 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26048 result = (wxPoint *) &_result_ref;
26049 }
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj = 0;
26062 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26063 wxPoint *arg2 = 0 ;
26064 void *argp1 = 0 ;
26065 int res1 = 0 ;
26066 wxPoint temp2 ;
26067 PyObject * obj0 = 0 ;
26068 PyObject * obj1 = 0 ;
26069 char * kwnames[] = {
26070 (char *) "self",(char *) "pos", NULL
26071 };
26072
26073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26075 if (!SWIG_IsOK(res1)) {
26076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26077 }
26078 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26079 {
26080 arg2 = &temp2;
26081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 (arg1)->SetPosition((wxPoint const &)*arg2);
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_Py_Void();
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 PyObject *obj;
26098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26099 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26100 return SWIG_Py_Void();
26101 }
26102
26103 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26104 return SWIG_Python_InitShadowInstance(args);
26105 }
26106
26107 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxIdleEvent *result = 0 ;
26110
26111 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxIdleEvent *)new wxIdleEvent();
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj = 0;
26127 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26128 bool arg2 = (bool) true ;
26129 void *argp1 = 0 ;
26130 int res1 = 0 ;
26131 bool val2 ;
26132 int ecode2 = 0 ;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char * kwnames[] = {
26136 (char *) "self",(char *) "needMore", NULL
26137 };
26138
26139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26145 if (obj1) {
26146 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26147 if (!SWIG_IsOK(ecode2)) {
26148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26149 }
26150 arg2 = static_cast< bool >(val2);
26151 }
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 (arg1)->RequestMore(arg2);
26155 wxPyEndAllowThreads(__tstate);
26156 if (PyErr_Occurred()) SWIG_fail;
26157 }
26158 resultobj = SWIG_Py_Void();
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 PyObject *resultobj = 0;
26167 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26168 bool result;
26169 void *argp1 = 0 ;
26170 int res1 = 0 ;
26171 PyObject *swig_obj[1] ;
26172
26173 if (!args) SWIG_fail;
26174 swig_obj[0] = args;
26175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26178 }
26179 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26180 {
26181 PyThreadState* __tstate = wxPyBeginAllowThreads();
26182 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26183 wxPyEndAllowThreads(__tstate);
26184 if (PyErr_Occurred()) SWIG_fail;
26185 }
26186 {
26187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26188 }
26189 return resultobj;
26190 fail:
26191 return NULL;
26192 }
26193
26194
26195 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj = 0;
26197 wxIdleMode arg1 ;
26198 int val1 ;
26199 int ecode1 = 0 ;
26200 PyObject * obj0 = 0 ;
26201 char * kwnames[] = {
26202 (char *) "mode", NULL
26203 };
26204
26205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26206 ecode1 = SWIG_AsVal_int(obj0, &val1);
26207 if (!SWIG_IsOK(ecode1)) {
26208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26209 }
26210 arg1 = static_cast< wxIdleMode >(val1);
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 wxIdleEvent::SetMode(arg1);
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 resultobj = SWIG_Py_Void();
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *resultobj = 0;
26226 wxIdleMode result;
26227
26228 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = (wxIdleMode)wxIdleEvent::GetMode();
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_From_int(static_cast< int >(result));
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxWindow *arg1 = (wxWindow *) 0 ;
26245 bool result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject * obj0 = 0 ;
26249 char * kwnames[] = {
26250 (char *) "win", NULL
26251 };
26252
26253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26257 }
26258 arg1 = reinterpret_cast< wxWindow * >(argp1);
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = (bool)wxIdleEvent::CanSend(arg1);
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 {
26266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26267 }
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *obj;
26276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26277 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26278 return SWIG_Py_Void();
26279 }
26280
26281 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 return SWIG_Python_InitShadowInstance(args);
26283 }
26284
26285 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj = 0;
26287 int arg1 = (int) 0 ;
26288 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26289 wxPyEvent *result = 0 ;
26290 int val1 ;
26291 int ecode1 = 0 ;
26292 int val2 ;
26293 int ecode2 = 0 ;
26294 PyObject * obj0 = 0 ;
26295 PyObject * obj1 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "winid",(char *) "eventType", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26301 if (obj0) {
26302 ecode1 = SWIG_AsVal_int(obj0, &val1);
26303 if (!SWIG_IsOK(ecode1)) {
26304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26305 }
26306 arg1 = static_cast< int >(val1);
26307 }
26308 if (obj1) {
26309 ecode2 = SWIG_AsVal_int(obj1, &val2);
26310 if (!SWIG_IsOK(ecode2)) {
26311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26312 }
26313 arg2 = static_cast< wxEventType >(val2);
26314 }
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26329 PyObject *resultobj = 0;
26330 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 PyObject *swig_obj[1] ;
26334
26335 if (!args) SWIG_fail;
26336 swig_obj[0] = args;
26337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26338 if (!SWIG_IsOK(res1)) {
26339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26340 }
26341 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 delete arg1;
26345
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_Py_Void();
26350 return resultobj;
26351 fail:
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26357 PyObject *resultobj = 0;
26358 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26359 PyObject *arg2 = (PyObject *) 0 ;
26360 void *argp1 = 0 ;
26361 int res1 = 0 ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char * kwnames[] = {
26365 (char *) "self",(char *) "self", NULL
26366 };
26367
26368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26372 }
26373 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26374 arg2 = obj1;
26375 {
26376 PyThreadState* __tstate = wxPyBeginAllowThreads();
26377 (arg1)->SetSelf(arg2);
26378 wxPyEndAllowThreads(__tstate);
26379 if (PyErr_Occurred()) SWIG_fail;
26380 }
26381 resultobj = SWIG_Py_Void();
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26389 PyObject *resultobj = 0;
26390 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26391 PyObject *result = 0 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject *swig_obj[1] ;
26395
26396 if (!args) SWIG_fail;
26397 swig_obj[0] = args;
26398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26399 if (!SWIG_IsOK(res1)) {
26400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26401 }
26402 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 result = (PyObject *)(arg1)->GetSelf();
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 resultobj = result;
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26417 PyObject *obj;
26418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26419 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26420 return SWIG_Py_Void();
26421 }
26422
26423 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 return SWIG_Python_InitShadowInstance(args);
26425 }
26426
26427 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj = 0;
26429 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26430 int arg2 = (int) 0 ;
26431 wxPyCommandEvent *result = 0 ;
26432 int val1 ;
26433 int ecode1 = 0 ;
26434 int val2 ;
26435 int ecode2 = 0 ;
26436 PyObject * obj0 = 0 ;
26437 PyObject * obj1 = 0 ;
26438 char * kwnames[] = {
26439 (char *) "eventType",(char *) "id", NULL
26440 };
26441
26442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26443 if (obj0) {
26444 ecode1 = SWIG_AsVal_int(obj0, &val1);
26445 if (!SWIG_IsOK(ecode1)) {
26446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26447 }
26448 arg1 = static_cast< wxEventType >(val1);
26449 }
26450 if (obj1) {
26451 ecode2 = SWIG_AsVal_int(obj1, &val2);
26452 if (!SWIG_IsOK(ecode2)) {
26453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26454 }
26455 arg2 = static_cast< int >(val2);
26456 }
26457 {
26458 PyThreadState* __tstate = wxPyBeginAllowThreads();
26459 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26464 return resultobj;
26465 fail:
26466 return NULL;
26467 }
26468
26469
26470 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26471 PyObject *resultobj = 0;
26472 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26473 void *argp1 = 0 ;
26474 int res1 = 0 ;
26475 PyObject *swig_obj[1] ;
26476
26477 if (!args) SWIG_fail;
26478 swig_obj[0] = args;
26479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26482 }
26483 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 delete arg1;
26487
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_Py_Void();
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj = 0;
26500 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26501 PyObject *arg2 = (PyObject *) 0 ;
26502 void *argp1 = 0 ;
26503 int res1 = 0 ;
26504 PyObject * obj0 = 0 ;
26505 PyObject * obj1 = 0 ;
26506 char * kwnames[] = {
26507 (char *) "self",(char *) "self", NULL
26508 };
26509
26510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26512 if (!SWIG_IsOK(res1)) {
26513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26514 }
26515 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26516 arg2 = obj1;
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 (arg1)->SetSelf(arg2);
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_Py_Void();
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26531 PyObject *resultobj = 0;
26532 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26533 PyObject *result = 0 ;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 PyObject *swig_obj[1] ;
26537
26538 if (!args) SWIG_fail;
26539 swig_obj[0] = args;
26540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26541 if (!SWIG_IsOK(res1)) {
26542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26543 }
26544 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 result = (PyObject *)(arg1)->GetSelf();
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 resultobj = result;
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26559 PyObject *obj;
26560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26562 return SWIG_Py_Void();
26563 }
26564
26565 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 return SWIG_Python_InitShadowInstance(args);
26567 }
26568
26569 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26570 PyObject *resultobj = 0;
26571 wxWindow *arg1 = (wxWindow *) 0 ;
26572 wxDateTime *arg2 = 0 ;
26573 wxEventType arg3 ;
26574 wxDateEvent *result = 0 ;
26575 void *argp1 = 0 ;
26576 int res1 = 0 ;
26577 void *argp2 = 0 ;
26578 int res2 = 0 ;
26579 int val3 ;
26580 int ecode3 = 0 ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 PyObject * obj2 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "win",(char *) "dt",(char *) "type", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26592 }
26593 arg1 = reinterpret_cast< wxWindow * >(argp1);
26594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26595 if (!SWIG_IsOK(res2)) {
26596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26597 }
26598 if (!argp2) {
26599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26600 }
26601 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26602 ecode3 = SWIG_AsVal_int(obj2, &val3);
26603 if (!SWIG_IsOK(ecode3)) {
26604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26605 }
26606 arg3 = static_cast< wxEventType >(val3);
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26621 PyObject *resultobj = 0;
26622 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26623 wxDateTime *result = 0 ;
26624 void *argp1 = 0 ;
26625 int res1 = 0 ;
26626 PyObject *swig_obj[1] ;
26627
26628 if (!args) SWIG_fail;
26629 swig_obj[0] = args;
26630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26631 if (!SWIG_IsOK(res1)) {
26632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26633 }
26634 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 {
26638 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26639 result = (wxDateTime *) &_result_ref;
26640 }
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj = 0;
26653 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26654 wxDateTime *arg2 = 0 ;
26655 void *argp1 = 0 ;
26656 int res1 = 0 ;
26657 void *argp2 = 0 ;
26658 int res2 = 0 ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "self",(char *) "date", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26669 }
26670 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26672 if (!SWIG_IsOK(res2)) {
26673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26674 }
26675 if (!argp2) {
26676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26677 }
26678 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->SetDate((wxDateTime const &)*arg2);
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 resultobj = SWIG_Py_Void();
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26693 PyObject *obj;
26694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26695 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26696 return SWIG_Py_Void();
26697 }
26698
26699 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26700 return SWIG_Python_InitShadowInstance(args);
26701 }
26702
26703 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26704 PyObject *resultobj = 0;
26705 wxPyApp *result = 0 ;
26706
26707 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxPyApp *)new_wxPyApp();
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxPyApp *arg1 = (wxPyApp *) 0 ;
26724 void *argp1 = 0 ;
26725 int res1 = 0 ;
26726 PyObject *swig_obj[1] ;
26727
26728 if (!args) SWIG_fail;
26729 swig_obj[0] = args;
26730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26733 }
26734 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 delete arg1;
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 resultobj = SWIG_Py_Void();
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxPyApp *arg1 = (wxPyApp *) 0 ;
26752 PyObject *arg2 = (PyObject *) 0 ;
26753 PyObject *arg3 = (PyObject *) 0 ;
26754 bool arg4 ;
26755 void *argp1 = 0 ;
26756 int res1 = 0 ;
26757 bool val4 ;
26758 int ecode4 = 0 ;
26759 PyObject * obj0 = 0 ;
26760 PyObject * obj1 = 0 ;
26761 PyObject * obj2 = 0 ;
26762 PyObject * obj3 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26771 }
26772 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26773 arg2 = obj1;
26774 arg3 = obj2;
26775 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26776 if (!SWIG_IsOK(ecode4)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26778 }
26779 arg4 = static_cast< bool >(val4);
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_Py_Void();
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 PyObject *resultobj = 0;
26795 wxPyApp *arg1 = (wxPyApp *) 0 ;
26796 wxString result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26806 }
26807 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = ((wxPyApp const *)arg1)->GetAppName();
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 {
26815 #if wxUSE_UNICODE
26816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26817 #else
26818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26819 #endif
26820 }
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj = 0;
26829 wxPyApp *arg1 = (wxPyApp *) 0 ;
26830 wxString *arg2 = 0 ;
26831 void *argp1 = 0 ;
26832 int res1 = 0 ;
26833 bool temp2 = false ;
26834 PyObject * obj0 = 0 ;
26835 PyObject * obj1 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "self",(char *) "name", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26842 if (!SWIG_IsOK(res1)) {
26843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26844 }
26845 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26846 {
26847 arg2 = wxString_in_helper(obj1);
26848 if (arg2 == NULL) SWIG_fail;
26849 temp2 = true;
26850 }
26851 {
26852 PyThreadState* __tstate = wxPyBeginAllowThreads();
26853 (arg1)->SetAppName((wxString const &)*arg2);
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 resultobj = SWIG_Py_Void();
26858 {
26859 if (temp2)
26860 delete arg2;
26861 }
26862 return resultobj;
26863 fail:
26864 {
26865 if (temp2)
26866 delete arg2;
26867 }
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 PyObject *resultobj = 0;
26874 wxPyApp *arg1 = (wxPyApp *) 0 ;
26875 wxString result;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 PyObject *swig_obj[1] ;
26879
26880 if (!args) SWIG_fail;
26881 swig_obj[0] = args;
26882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26883 if (!SWIG_IsOK(res1)) {
26884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26885 }
26886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = ((wxPyApp const *)arg1)->GetClassName();
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 {
26894 #if wxUSE_UNICODE
26895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26896 #else
26897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26898 #endif
26899 }
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj = 0;
26908 wxPyApp *arg1 = (wxPyApp *) 0 ;
26909 wxString *arg2 = 0 ;
26910 void *argp1 = 0 ;
26911 int res1 = 0 ;
26912 bool temp2 = false ;
26913 PyObject * obj0 = 0 ;
26914 PyObject * obj1 = 0 ;
26915 char * kwnames[] = {
26916 (char *) "self",(char *) "name", NULL
26917 };
26918
26919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26921 if (!SWIG_IsOK(res1)) {
26922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26923 }
26924 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26925 {
26926 arg2 = wxString_in_helper(obj1);
26927 if (arg2 == NULL) SWIG_fail;
26928 temp2 = true;
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetClassName((wxString const &)*arg2);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 {
26938 if (temp2)
26939 delete arg2;
26940 }
26941 return resultobj;
26942 fail:
26943 {
26944 if (temp2)
26945 delete arg2;
26946 }
26947 return NULL;
26948 }
26949
26950
26951 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 PyObject *resultobj = 0;
26953 wxPyApp *arg1 = (wxPyApp *) 0 ;
26954 wxString *result = 0 ;
26955 void *argp1 = 0 ;
26956 int res1 = 0 ;
26957 PyObject *swig_obj[1] ;
26958
26959 if (!args) SWIG_fail;
26960 swig_obj[0] = args;
26961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26962 if (!SWIG_IsOK(res1)) {
26963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26964 }
26965 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 {
26969 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26970 result = (wxString *) &_result_ref;
26971 }
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 #if wxUSE_UNICODE
26977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26978 #else
26979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26980 #endif
26981 }
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj = 0;
26990 wxPyApp *arg1 = (wxPyApp *) 0 ;
26991 wxString *arg2 = 0 ;
26992 void *argp1 = 0 ;
26993 int res1 = 0 ;
26994 bool temp2 = false ;
26995 PyObject * obj0 = 0 ;
26996 PyObject * obj1 = 0 ;
26997 char * kwnames[] = {
26998 (char *) "self",(char *) "name", NULL
26999 };
27000
27001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27003 if (!SWIG_IsOK(res1)) {
27004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27005 }
27006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27007 {
27008 arg2 = wxString_in_helper(obj1);
27009 if (arg2 == NULL) SWIG_fail;
27010 temp2 = true;
27011 }
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 (arg1)->SetVendorName((wxString const &)*arg2);
27015 wxPyEndAllowThreads(__tstate);
27016 if (PyErr_Occurred()) SWIG_fail;
27017 }
27018 resultobj = SWIG_Py_Void();
27019 {
27020 if (temp2)
27021 delete arg2;
27022 }
27023 return resultobj;
27024 fail:
27025 {
27026 if (temp2)
27027 delete arg2;
27028 }
27029 return NULL;
27030 }
27031
27032
27033 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27034 PyObject *resultobj = 0;
27035 wxPyApp *arg1 = (wxPyApp *) 0 ;
27036 wxAppTraits *result = 0 ;
27037 void *argp1 = 0 ;
27038 int res1 = 0 ;
27039 PyObject *swig_obj[1] ;
27040
27041 if (!args) SWIG_fail;
27042 swig_obj[0] = args;
27043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27044 if (!SWIG_IsOK(res1)) {
27045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27046 }
27047 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = (wxAppTraits *)(arg1)->GetTraits();
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27062 PyObject *resultobj = 0;
27063 wxPyApp *arg1 = (wxPyApp *) 0 ;
27064 void *argp1 = 0 ;
27065 int res1 = 0 ;
27066 PyObject *swig_obj[1] ;
27067
27068 if (!args) SWIG_fail;
27069 swig_obj[0] = args;
27070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27073 }
27074 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 (arg1)->ProcessPendingEvents();
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 resultobj = SWIG_Py_Void();
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = 0;
27090 wxPyApp *arg1 = (wxPyApp *) 0 ;
27091 bool arg2 = (bool) false ;
27092 bool result;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool val2 ;
27096 int ecode2 = 0 ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "onlyIfNeeded", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27107 }
27108 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27109 if (obj1) {
27110 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27111 if (!SWIG_IsOK(ecode2)) {
27112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27113 }
27114 arg2 = static_cast< bool >(val2);
27115 }
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 result = (bool)(arg1)->Yield(arg2);
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27124 }
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27132 PyObject *resultobj = 0;
27133 wxPyApp *arg1 = (wxPyApp *) 0 ;
27134 void *argp1 = 0 ;
27135 int res1 = 0 ;
27136 PyObject *swig_obj[1] ;
27137
27138 if (!args) SWIG_fail;
27139 swig_obj[0] = args;
27140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27141 if (!SWIG_IsOK(res1)) {
27142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27143 }
27144 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 (arg1)->WakeUpIdle();
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 resultobj = SWIG_Py_Void();
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27159 PyObject *resultobj = 0;
27160 bool result;
27161
27162 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27163 {
27164 PyThreadState* __tstate = wxPyBeginAllowThreads();
27165 result = (bool)wxPyApp::IsMainLoopRunning();
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27179 PyObject *resultobj = 0;
27180 wxPyApp *arg1 = (wxPyApp *) 0 ;
27181 int result;
27182 void *argp1 = 0 ;
27183 int res1 = 0 ;
27184 PyObject *swig_obj[1] ;
27185
27186 if (!args) SWIG_fail;
27187 swig_obj[0] = args;
27188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27191 }
27192 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (int)(arg1)->MainLoop();
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 resultobj = SWIG_From_int(static_cast< int >(result));
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27207 PyObject *resultobj = 0;
27208 wxPyApp *arg1 = (wxPyApp *) 0 ;
27209 void *argp1 = 0 ;
27210 int res1 = 0 ;
27211 PyObject *swig_obj[1] ;
27212
27213 if (!args) SWIG_fail;
27214 swig_obj[0] = args;
27215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27216 if (!SWIG_IsOK(res1)) {
27217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27218 }
27219 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 (arg1)->Exit();
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_Py_Void();
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27234 PyObject *resultobj = 0;
27235 wxPyApp *arg1 = (wxPyApp *) 0 ;
27236 void *argp1 = 0 ;
27237 int res1 = 0 ;
27238 PyObject *swig_obj[1] ;
27239
27240 if (!args) SWIG_fail;
27241 swig_obj[0] = args;
27242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27245 }
27246 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 (arg1)->ExitMainLoop();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = SWIG_Py_Void();
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27261 PyObject *resultobj = 0;
27262 wxPyApp *arg1 = (wxPyApp *) 0 ;
27263 bool result;
27264 void *argp1 = 0 ;
27265 int res1 = 0 ;
27266 PyObject *swig_obj[1] ;
27267
27268 if (!args) SWIG_fail;
27269 swig_obj[0] = args;
27270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27273 }
27274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 result = (bool)(arg1)->Pending();
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 {
27282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27291 PyObject *resultobj = 0;
27292 wxPyApp *arg1 = (wxPyApp *) 0 ;
27293 bool result;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 PyObject *swig_obj[1] ;
27297
27298 if (!args) SWIG_fail;
27299 swig_obj[0] = args;
27300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27303 }
27304 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)(arg1)->Dispatch();
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27313 }
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27321 PyObject *resultobj = 0;
27322 wxPyApp *arg1 = (wxPyApp *) 0 ;
27323 bool result;
27324 void *argp1 = 0 ;
27325 int res1 = 0 ;
27326 PyObject *swig_obj[1] ;
27327
27328 if (!args) SWIG_fail;
27329 swig_obj[0] = args;
27330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27331 if (!SWIG_IsOK(res1)) {
27332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27333 }
27334 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 result = (bool)(arg1)->ProcessIdle();
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 {
27342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27343 }
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj = 0;
27352 wxPyApp *arg1 = (wxPyApp *) 0 ;
27353 wxWindow *arg2 = (wxWindow *) 0 ;
27354 wxIdleEvent *arg3 = 0 ;
27355 bool result;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 void *argp2 = 0 ;
27359 int res2 = 0 ;
27360 void *argp3 = 0 ;
27361 int res3 = 0 ;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 PyObject * obj2 = 0 ;
27365 char * kwnames[] = {
27366 (char *) "self",(char *) "win",(char *) "event", NULL
27367 };
27368
27369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27371 if (!SWIG_IsOK(res1)) {
27372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27373 }
27374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27376 if (!SWIG_IsOK(res2)) {
27377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27378 }
27379 arg2 = reinterpret_cast< wxWindow * >(argp2);
27380 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27381 if (!SWIG_IsOK(res3)) {
27382 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27383 }
27384 if (!argp3) {
27385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27386 }
27387 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 {
27395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27396 }
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 PyObject *resultobj = 0;
27405 wxPyApp *arg1 = (wxPyApp *) 0 ;
27406 bool result;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 PyObject *swig_obj[1] ;
27410
27411 if (!args) SWIG_fail;
27412 swig_obj[0] = args;
27413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27414 if (!SWIG_IsOK(res1)) {
27415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27416 }
27417 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 result = (bool)((wxPyApp const *)arg1)->IsActive();
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 {
27425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27426 }
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj = 0;
27435 wxPyApp *arg1 = (wxPyApp *) 0 ;
27436 wxWindow *arg2 = (wxWindow *) 0 ;
27437 void *argp1 = 0 ;
27438 int res1 = 0 ;
27439 void *argp2 = 0 ;
27440 int res2 = 0 ;
27441 PyObject * obj0 = 0 ;
27442 PyObject * obj1 = 0 ;
27443 char * kwnames[] = {
27444 (char *) "self",(char *) "win", NULL
27445 };
27446
27447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27454 if (!SWIG_IsOK(res2)) {
27455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27456 }
27457 arg2 = reinterpret_cast< wxWindow * >(argp2);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 (arg1)->SetTopWindow(arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_Py_Void();
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxPyApp *arg1 = (wxPyApp *) 0 ;
27474 wxWindow *result = 0 ;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27484 }
27485 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = wxPyMake_wxObject(result, (bool)0);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj = 0;
27503 wxPyApp *arg1 = (wxPyApp *) 0 ;
27504 bool arg2 ;
27505 void *argp1 = 0 ;
27506 int res1 = 0 ;
27507 bool val2 ;
27508 int ecode2 = 0 ;
27509 PyObject * obj0 = 0 ;
27510 PyObject * obj1 = 0 ;
27511 char * kwnames[] = {
27512 (char *) "self",(char *) "flag", NULL
27513 };
27514
27515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27517 if (!SWIG_IsOK(res1)) {
27518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27519 }
27520 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27521 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27522 if (!SWIG_IsOK(ecode2)) {
27523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27524 }
27525 arg2 = static_cast< bool >(val2);
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 (arg1)->SetExitOnFrameDelete(arg2);
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 resultobj = SWIG_Py_Void();
27533 return resultobj;
27534 fail:
27535 return NULL;
27536 }
27537
27538
27539 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxPyApp *arg1 = (wxPyApp *) 0 ;
27542 bool result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27552 }
27553 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 {
27561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27562 }
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27570 PyObject *resultobj = 0;
27571 wxPyApp *arg1 = (wxPyApp *) 0 ;
27572 bool arg2 ;
27573 void *argp1 = 0 ;
27574 int res1 = 0 ;
27575 bool val2 ;
27576 int ecode2 = 0 ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 char * kwnames[] = {
27580 (char *) "self",(char *) "flag", NULL
27581 };
27582
27583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27587 }
27588 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27590 if (!SWIG_IsOK(ecode2)) {
27591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27592 }
27593 arg2 = static_cast< bool >(val2);
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 (arg1)->SetUseBestVisual(arg2);
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 resultobj = SWIG_Py_Void();
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 PyObject *resultobj = 0;
27609 wxPyApp *arg1 = (wxPyApp *) 0 ;
27610 bool result;
27611 void *argp1 = 0 ;
27612 int res1 = 0 ;
27613 PyObject *swig_obj[1] ;
27614
27615 if (!args) SWIG_fail;
27616 swig_obj[0] = args;
27617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27618 if (!SWIG_IsOK(res1)) {
27619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27620 }
27621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27625 wxPyEndAllowThreads(__tstate);
27626 if (PyErr_Occurred()) SWIG_fail;
27627 }
27628 {
27629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27630 }
27631 return resultobj;
27632 fail:
27633 return NULL;
27634 }
27635
27636
27637 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27638 PyObject *resultobj = 0;
27639 wxPyApp *arg1 = (wxPyApp *) 0 ;
27640 int arg2 ;
27641 void *argp1 = 0 ;
27642 int res1 = 0 ;
27643 int val2 ;
27644 int ecode2 = 0 ;
27645 PyObject * obj0 = 0 ;
27646 PyObject * obj1 = 0 ;
27647 char * kwnames[] = {
27648 (char *) "self",(char *) "mode", NULL
27649 };
27650
27651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27653 if (!SWIG_IsOK(res1)) {
27654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27655 }
27656 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27657 ecode2 = SWIG_AsVal_int(obj1, &val2);
27658 if (!SWIG_IsOK(ecode2)) {
27659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27660 }
27661 arg2 = static_cast< int >(val2);
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 (arg1)->SetPrintMode(arg2);
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 resultobj = SWIG_Py_Void();
27669 return resultobj;
27670 fail:
27671 return NULL;
27672 }
27673
27674
27675 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27676 PyObject *resultobj = 0;
27677 wxPyApp *arg1 = (wxPyApp *) 0 ;
27678 int result;
27679 void *argp1 = 0 ;
27680 int res1 = 0 ;
27681 PyObject *swig_obj[1] ;
27682
27683 if (!args) SWIG_fail;
27684 swig_obj[0] = args;
27685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27686 if (!SWIG_IsOK(res1)) {
27687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27688 }
27689 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_From_int(static_cast< int >(result));
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj = 0;
27705 wxPyApp *arg1 = (wxPyApp *) 0 ;
27706 int arg2 ;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 int val2 ;
27710 int ecode2 = 0 ;
27711 PyObject * obj0 = 0 ;
27712 PyObject * obj1 = 0 ;
27713 char * kwnames[] = {
27714 (char *) "self",(char *) "mode", NULL
27715 };
27716
27717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27721 }
27722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27723 ecode2 = SWIG_AsVal_int(obj1, &val2);
27724 if (!SWIG_IsOK(ecode2)) {
27725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27726 }
27727 arg2 = static_cast< int >(val2);
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetAssertMode(arg2);
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_Py_Void();
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742 PyObject *resultobj = 0;
27743 wxPyApp *arg1 = (wxPyApp *) 0 ;
27744 int result;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 PyObject *swig_obj[1] ;
27748
27749 if (!args) SWIG_fail;
27750 swig_obj[0] = args;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27754 }
27755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (int)(arg1)->GetAssertMode();
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_From_int(static_cast< int >(result));
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 bool result;
27772
27773 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27777 wxPyEndAllowThreads(__tstate);
27778 if (PyErr_Occurred()) SWIG_fail;
27779 }
27780 {
27781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27782 }
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27790 PyObject *resultobj = 0;
27791 long result;
27792
27793 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 result = (long)wxPyApp::GetMacAboutMenuItemId();
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 resultobj = SWIG_From_long(static_cast< long >(result));
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27808 PyObject *resultobj = 0;
27809 long result;
27810
27811 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_From_long(static_cast< long >(result));
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 long result;
27828
27829 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 result = (long)wxPyApp::GetMacExitMenuItemId();
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_From_long(static_cast< long >(result));
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27844 PyObject *resultobj = 0;
27845 wxString result;
27846
27847 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = wxPyApp::GetMacHelpMenuTitleName();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 #if wxUSE_UNICODE
27856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27857 #else
27858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27859 #endif
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 bool arg1 ;
27870 bool val1 ;
27871 int ecode1 = 0 ;
27872 PyObject * obj0 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "val", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27878 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27879 if (!SWIG_IsOK(ecode1)) {
27880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27881 }
27882 arg1 = static_cast< bool >(val1);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 resultobj = SWIG_Py_Void();
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj = 0;
27898 long arg1 ;
27899 long val1 ;
27900 int ecode1 = 0 ;
27901 PyObject * obj0 = 0 ;
27902 char * kwnames[] = {
27903 (char *) "val", NULL
27904 };
27905
27906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27907 ecode1 = SWIG_AsVal_long(obj0, &val1);
27908 if (!SWIG_IsOK(ecode1)) {
27909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27910 }
27911 arg1 = static_cast< long >(val1);
27912 {
27913 PyThreadState* __tstate = wxPyBeginAllowThreads();
27914 wxPyApp::SetMacAboutMenuItemId(arg1);
27915 wxPyEndAllowThreads(__tstate);
27916 if (PyErr_Occurred()) SWIG_fail;
27917 }
27918 resultobj = SWIG_Py_Void();
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27926 PyObject *resultobj = 0;
27927 long arg1 ;
27928 long val1 ;
27929 int ecode1 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "val", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27936 ecode1 = SWIG_AsVal_long(obj0, &val1);
27937 if (!SWIG_IsOK(ecode1)) {
27938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27939 }
27940 arg1 = static_cast< long >(val1);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_Py_Void();
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj = 0;
27956 long arg1 ;
27957 long val1 ;
27958 int ecode1 = 0 ;
27959 PyObject * obj0 = 0 ;
27960 char * kwnames[] = {
27961 (char *) "val", NULL
27962 };
27963
27964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27965 ecode1 = SWIG_AsVal_long(obj0, &val1);
27966 if (!SWIG_IsOK(ecode1)) {
27967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27968 }
27969 arg1 = static_cast< long >(val1);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 wxPyApp::SetMacExitMenuItemId(arg1);
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 resultobj = SWIG_Py_Void();
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj = 0;
27985 wxString *arg1 = 0 ;
27986 bool temp1 = false ;
27987 PyObject * obj0 = 0 ;
27988 char * kwnames[] = {
27989 (char *) "val", NULL
27990 };
27991
27992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27993 {
27994 arg1 = wxString_in_helper(obj0);
27995 if (arg1 == NULL) SWIG_fail;
27996 temp1 = true;
27997 }
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 resultobj = SWIG_Py_Void();
28005 {
28006 if (temp1)
28007 delete arg1;
28008 }
28009 return resultobj;
28010 fail:
28011 {
28012 if (temp1)
28013 delete arg1;
28014 }
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28020 PyObject *resultobj = 0;
28021 wxPyApp *arg1 = (wxPyApp *) 0 ;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 PyObject *swig_obj[1] ;
28025
28026 if (!args) SWIG_fail;
28027 swig_obj[0] = args;
28028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28031 }
28032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 (arg1)->_BootstrapApp();
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28047 PyObject *resultobj = 0;
28048 int result;
28049
28050 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = (int)wxPyApp_GetComCtl32Version();
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_From_int(static_cast< int >(result));
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28065 PyObject *obj;
28066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28067 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28068 return SWIG_Py_Void();
28069 }
28070
28071 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28072 return SWIG_Python_InitShadowInstance(args);
28073 }
28074
28075 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28076 PyObject *resultobj = 0;
28077
28078 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 wxExit();
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_Py_Void();
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28093 PyObject *resultobj = 0;
28094 bool result;
28095
28096 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 result = (bool)wxYield();
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 {
28104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28105 }
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28113 PyObject *resultobj = 0;
28114 bool result;
28115
28116 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)wxYieldIfNeeded();
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 {
28124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28125 }
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 wxWindow *arg1 = (wxWindow *) NULL ;
28135 bool arg2 = (bool) false ;
28136 bool result;
28137 void *argp1 = 0 ;
28138 int res1 = 0 ;
28139 bool val2 ;
28140 int ecode2 = 0 ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 char * kwnames[] = {
28144 (char *) "win",(char *) "onlyIfNeeded", NULL
28145 };
28146
28147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28148 if (obj0) {
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28152 }
28153 arg1 = reinterpret_cast< wxWindow * >(argp1);
28154 }
28155 if (obj1) {
28156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28157 if (!SWIG_IsOK(ecode2)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28159 }
28160 arg2 = static_cast< bool >(val2);
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (bool)wxSafeYield(arg1,arg2);
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 {
28169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28170 }
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28178 PyObject *resultobj = 0;
28179
28180 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 wxWakeUpIdle();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28197 wxEvent *arg2 = 0 ;
28198 void *argp1 = 0 ;
28199 int res1 = 0 ;
28200 void *argp2 = 0 ;
28201 int res2 = 0 ;
28202 PyObject * obj0 = 0 ;
28203 PyObject * obj1 = 0 ;
28204 char * kwnames[] = {
28205 (char *) "dest",(char *) "event", NULL
28206 };
28207
28208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28210 if (!SWIG_IsOK(res1)) {
28211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28212 }
28213 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28215 if (!SWIG_IsOK(res2)) {
28216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28217 }
28218 if (!argp2) {
28219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28220 }
28221 arg2 = reinterpret_cast< wxEvent * >(argp2);
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 wxPostEvent(arg1,*arg2);
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 resultobj = SWIG_Py_Void();
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237
28238 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 wxApp_CleanUp();
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_Py_Void();
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *resultobj = 0;
28254 wxPyApp *result = 0 ;
28255
28256 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (wxPyApp *)wxPyGetApp();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = wxPyMake_wxObject(result, 0);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj = 0;
28274 char *arg1 = (char *) 0 ;
28275 int res1 ;
28276 char *buf1 = 0 ;
28277 int alloc1 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 char * kwnames[] = {
28280 (char *) "encoding", NULL
28281 };
28282
28283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28284 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28285 if (!SWIG_IsOK(res1)) {
28286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28287 }
28288 arg1 = buf1;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 wxSetDefaultPyEncoding((char const *)arg1);
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 resultobj = SWIG_Py_Void();
28296 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28297 return resultobj;
28298 fail:
28299 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 char *result = 0 ;
28307
28308 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (char *)wxGetDefaultPyEncoding();
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 resultobj = SWIG_FromCharPtr(result);
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 PyObject *resultobj = 0;
28324 wxEventLoop *result = 0 ;
28325
28326 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (wxEventLoop *)new wxEventLoop();
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28341 PyObject *resultobj = 0;
28342 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28343 void *argp1 = 0 ;
28344 int res1 = 0 ;
28345 PyObject *swig_obj[1] ;
28346
28347 if (!args) SWIG_fail;
28348 swig_obj[0] = args;
28349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28352 }
28353 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 delete arg1;
28357
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 resultobj = SWIG_Py_Void();
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28369 PyObject *resultobj = 0;
28370 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28371 int result;
28372 void *argp1 = 0 ;
28373 int res1 = 0 ;
28374 PyObject *swig_obj[1] ;
28375
28376 if (!args) SWIG_fail;
28377 swig_obj[0] = args;
28378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28379 if (!SWIG_IsOK(res1)) {
28380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28381 }
28382 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 result = (int)(arg1)->Run();
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_From_int(static_cast< int >(result));
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj = 0;
28398 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28399 int arg2 = (int) 0 ;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 int val2 ;
28403 int ecode2 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 PyObject * obj1 = 0 ;
28406 char * kwnames[] = {
28407 (char *) "self",(char *) "rc", NULL
28408 };
28409
28410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28412 if (!SWIG_IsOK(res1)) {
28413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28414 }
28415 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28416 if (obj1) {
28417 ecode2 = SWIG_AsVal_int(obj1, &val2);
28418 if (!SWIG_IsOK(ecode2)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28420 }
28421 arg2 = static_cast< int >(val2);
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 (arg1)->Exit(arg2);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_Py_Void();
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *resultobj = 0;
28438 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28439 bool result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 PyObject *swig_obj[1] ;
28443
28444 if (!args) SWIG_fail;
28445 swig_obj[0] = args;
28446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28447 if (!SWIG_IsOK(res1)) {
28448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28449 }
28450 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (bool)((wxEventLoop const *)arg1)->Pending();
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 {
28458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28467 PyObject *resultobj = 0;
28468 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28469 bool result;
28470 void *argp1 = 0 ;
28471 int res1 = 0 ;
28472 PyObject *swig_obj[1] ;
28473
28474 if (!args) SWIG_fail;
28475 swig_obj[0] = args;
28476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28479 }
28480 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = (bool)(arg1)->Dispatch();
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 {
28488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28489 }
28490 return resultobj;
28491 fail:
28492 return NULL;
28493 }
28494
28495
28496 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28497 PyObject *resultobj = 0;
28498 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28499 bool result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 PyObject *swig_obj[1] ;
28503
28504 if (!args) SWIG_fail;
28505 swig_obj[0] = args;
28506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28509 }
28510 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28519 }
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28527 PyObject *resultobj = 0;
28528 wxEventLoop *result = 0 ;
28529
28530 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxEventLoop *)wxEventLoop::GetActive();
28534 wxPyEndAllowThreads(__tstate);
28535 if (PyErr_Occurred()) SWIG_fail;
28536 }
28537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj = 0;
28546 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28547 void *argp1 = 0 ;
28548 int res1 = 0 ;
28549 PyObject * obj0 = 0 ;
28550 char * kwnames[] = {
28551 (char *) "loop", NULL
28552 };
28553
28554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28556 if (!SWIG_IsOK(res1)) {
28557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28558 }
28559 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 wxEventLoop::SetActive(arg1);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_Py_Void();
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *obj;
28575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28576 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28577 return SWIG_Py_Void();
28578 }
28579
28580 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28581 return SWIG_Python_InitShadowInstance(args);
28582 }
28583
28584 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28585 PyObject *resultobj = 0;
28586 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28587 wxEventLoopActivator *result = 0 ;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject * obj0 = 0 ;
28591 char * kwnames[] = {
28592 (char *) "evtLoop", NULL
28593 };
28594
28595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28599 }
28600 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28617 void *argp1 = 0 ;
28618 int res1 = 0 ;
28619 PyObject *swig_obj[1] ;
28620
28621 if (!args) SWIG_fail;
28622 swig_obj[0] = args;
28623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28626 }
28627 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 delete arg1;
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 resultobj = SWIG_Py_Void();
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *obj;
28644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28645 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28646 return SWIG_Py_Void();
28647 }
28648
28649 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 return SWIG_Python_InitShadowInstance(args);
28651 }
28652
28653 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28654 PyObject *resultobj = 0;
28655 int arg1 = (int) 0 ;
28656 int arg2 = (int) 0 ;
28657 int arg3 = (int) 0 ;
28658 wxAcceleratorEntry *result = 0 ;
28659 int val1 ;
28660 int ecode1 = 0 ;
28661 int val2 ;
28662 int ecode2 = 0 ;
28663 int val3 ;
28664 int ecode3 = 0 ;
28665 PyObject * obj0 = 0 ;
28666 PyObject * obj1 = 0 ;
28667 PyObject * obj2 = 0 ;
28668 char * kwnames[] = {
28669 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28670 };
28671
28672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28673 if (obj0) {
28674 ecode1 = SWIG_AsVal_int(obj0, &val1);
28675 if (!SWIG_IsOK(ecode1)) {
28676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28677 }
28678 arg1 = static_cast< int >(val1);
28679 }
28680 if (obj1) {
28681 ecode2 = SWIG_AsVal_int(obj1, &val2);
28682 if (!SWIG_IsOK(ecode2)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28684 }
28685 arg2 = static_cast< int >(val2);
28686 }
28687 if (obj2) {
28688 ecode3 = SWIG_AsVal_int(obj2, &val3);
28689 if (!SWIG_IsOK(ecode3)) {
28690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28691 }
28692 arg3 = static_cast< int >(val3);
28693 }
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28708 PyObject *resultobj = 0;
28709 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28710 void *argp1 = 0 ;
28711 int res1 = 0 ;
28712 PyObject *swig_obj[1] ;
28713
28714 if (!args) SWIG_fail;
28715 swig_obj[0] = args;
28716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28717 if (!SWIG_IsOK(res1)) {
28718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28719 }
28720 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28721 {
28722 PyThreadState* __tstate = wxPyBeginAllowThreads();
28723 delete arg1;
28724
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_Py_Void();
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj = 0;
28737 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28738 int arg2 ;
28739 int arg3 ;
28740 int arg4 ;
28741 void *argp1 = 0 ;
28742 int res1 = 0 ;
28743 int val2 ;
28744 int ecode2 = 0 ;
28745 int val3 ;
28746 int ecode3 = 0 ;
28747 int val4 ;
28748 int ecode4 = 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 PyObject * obj2 = 0 ;
28752 PyObject * obj3 = 0 ;
28753 char * kwnames[] = {
28754 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28759 if (!SWIG_IsOK(res1)) {
28760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28761 }
28762 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28763 ecode2 = SWIG_AsVal_int(obj1, &val2);
28764 if (!SWIG_IsOK(ecode2)) {
28765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28766 }
28767 arg2 = static_cast< int >(val2);
28768 ecode3 = SWIG_AsVal_int(obj2, &val3);
28769 if (!SWIG_IsOK(ecode3)) {
28770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28771 }
28772 arg3 = static_cast< int >(val3);
28773 ecode4 = SWIG_AsVal_int(obj3, &val4);
28774 if (!SWIG_IsOK(ecode4)) {
28775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28776 }
28777 arg4 = static_cast< int >(val4);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 (arg1)->Set(arg2,arg3,arg4);
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = SWIG_Py_Void();
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28792 PyObject *resultobj = 0;
28793 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28794 int result;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 PyObject *swig_obj[1] ;
28798
28799 if (!args) SWIG_fail;
28800 swig_obj[0] = args;
28801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28802 if (!SWIG_IsOK(res1)) {
28803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28804 }
28805 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (int)(arg1)->GetFlags();
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 resultobj = SWIG_From_int(static_cast< int >(result));
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28820 PyObject *resultobj = 0;
28821 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28822 int result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 PyObject *swig_obj[1] ;
28826
28827 if (!args) SWIG_fail;
28828 swig_obj[0] = args;
28829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28830 if (!SWIG_IsOK(res1)) {
28831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28832 }
28833 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (int)(arg1)->GetKeyCode();
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 resultobj = SWIG_From_int(static_cast< int >(result));
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28848 PyObject *resultobj = 0;
28849 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28850 int result;
28851 void *argp1 = 0 ;
28852 int res1 = 0 ;
28853 PyObject *swig_obj[1] ;
28854
28855 if (!args) SWIG_fail;
28856 swig_obj[0] = args;
28857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28858 if (!SWIG_IsOK(res1)) {
28859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28860 }
28861 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (int)(arg1)->GetCommand();
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 resultobj = SWIG_From_int(static_cast< int >(result));
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28876 PyObject *obj;
28877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28878 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28879 return SWIG_Py_Void();
28880 }
28881
28882 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28883 return SWIG_Python_InitShadowInstance(args);
28884 }
28885
28886 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj = 0;
28888 int arg1 ;
28889 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28890 wxAcceleratorTable *result = 0 ;
28891 PyObject * obj0 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "n", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28897 {
28898 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28899 if (arg2) arg1 = PyList_Size(obj0);
28900 else arg1 = 0;
28901 }
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28916 PyObject *resultobj = 0;
28917 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28918 void *argp1 = 0 ;
28919 int res1 = 0 ;
28920 PyObject *swig_obj[1] ;
28921
28922 if (!args) SWIG_fail;
28923 swig_obj[0] = args;
28924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28927 }
28928 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 delete arg1;
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_Py_Void();
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28946 bool result;
28947 void *argp1 = 0 ;
28948 int res1 = 0 ;
28949 PyObject *swig_obj[1] ;
28950
28951 if (!args) SWIG_fail;
28952 swig_obj[0] = args;
28953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28954 if (!SWIG_IsOK(res1)) {
28955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28956 }
28957 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 {
28965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28966 }
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28974 PyObject *obj;
28975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28976 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28977 return SWIG_Py_Void();
28978 }
28979
28980 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 return SWIG_Python_InitShadowInstance(args);
28982 }
28983
28984 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28985 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28986 return 1;
28987 }
28988
28989
28990 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28991 PyObject *pyobj = 0;
28992
28993 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28994 return pyobj;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28999 PyObject *resultobj = 0;
29000 wxString *arg1 = 0 ;
29001 wxAcceleratorEntry *result = 0 ;
29002 bool temp1 = false ;
29003 PyObject * obj0 = 0 ;
29004 char * kwnames[] = {
29005 (char *) "label", NULL
29006 };
29007
29008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29009 {
29010 arg1 = wxString_in_helper(obj0);
29011 if (arg1 == NULL) SWIG_fail;
29012 temp1 = true;
29013 }
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29021 {
29022 if (temp1)
29023 delete arg1;
29024 }
29025 return resultobj;
29026 fail:
29027 {
29028 if (temp1)
29029 delete arg1;
29030 }
29031 return NULL;
29032 }
29033
29034
29035 SWIGINTERN int PanelNameStr_set(PyObject *) {
29036 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29037 return 1;
29038 }
29039
29040
29041 SWIGINTERN PyObject *PanelNameStr_get(void) {
29042 PyObject *pyobj = 0;
29043
29044 {
29045 #if wxUSE_UNICODE
29046 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29047 #else
29048 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29049 #endif
29050 }
29051 return pyobj;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29056 PyObject *resultobj = 0;
29057 wxVisualAttributes *result = 0 ;
29058
29059 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 result = (wxVisualAttributes *)new_wxVisualAttributes();
29063 wxPyEndAllowThreads(__tstate);
29064 if (PyErr_Occurred()) SWIG_fail;
29065 }
29066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29067 return resultobj;
29068 fail:
29069 return NULL;
29070 }
29071
29072
29073 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29074 PyObject *resultobj = 0;
29075 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 PyObject *swig_obj[1] ;
29079
29080 if (!args) SWIG_fail;
29081 swig_obj[0] = args;
29082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29083 if (!SWIG_IsOK(res1)) {
29084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29085 }
29086 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 delete_wxVisualAttributes(arg1);
29090
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 resultobj = SWIG_Py_Void();
29095 return resultobj;
29096 fail:
29097 return NULL;
29098 }
29099
29100
29101 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29102 PyObject *resultobj = 0;
29103 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29104 wxFont *arg2 = (wxFont *) 0 ;
29105 void *argp1 = 0 ;
29106 int res1 = 0 ;
29107 void *argp2 = 0 ;
29108 int res2 = 0 ;
29109 PyObject *swig_obj[2] ;
29110
29111 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29113 if (!SWIG_IsOK(res1)) {
29114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29115 }
29116 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29117 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29118 if (!SWIG_IsOK(res2)) {
29119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29120 }
29121 arg2 = reinterpret_cast< wxFont * >(argp2);
29122 if (arg1) (arg1)->font = *arg2;
29123
29124 resultobj = SWIG_Py_Void();
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29132 PyObject *resultobj = 0;
29133 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29134 wxFont *result = 0 ;
29135 void *argp1 = 0 ;
29136 int res1 = 0 ;
29137 PyObject *swig_obj[1] ;
29138
29139 if (!args) SWIG_fail;
29140 swig_obj[0] = args;
29141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29142 if (!SWIG_IsOK(res1)) {
29143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29144 }
29145 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29146 result = (wxFont *)& ((arg1)->font);
29147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29155 PyObject *resultobj = 0;
29156 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29157 wxColour *arg2 = (wxColour *) 0 ;
29158 void *argp1 = 0 ;
29159 int res1 = 0 ;
29160 void *argp2 = 0 ;
29161 int res2 = 0 ;
29162 PyObject *swig_obj[2] ;
29163
29164 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29166 if (!SWIG_IsOK(res1)) {
29167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29168 }
29169 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29170 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29171 if (!SWIG_IsOK(res2)) {
29172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29173 }
29174 arg2 = reinterpret_cast< wxColour * >(argp2);
29175 if (arg1) (arg1)->colFg = *arg2;
29176
29177 resultobj = SWIG_Py_Void();
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29187 wxColour *result = 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29197 }
29198 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29199 result = (wxColour *)& ((arg1)->colFg);
29200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29208 PyObject *resultobj = 0;
29209 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29210 wxColour *arg2 = (wxColour *) 0 ;
29211 void *argp1 = 0 ;
29212 int res1 = 0 ;
29213 void *argp2 = 0 ;
29214 int res2 = 0 ;
29215 PyObject *swig_obj[2] ;
29216
29217 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29221 }
29222 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29223 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29224 if (!SWIG_IsOK(res2)) {
29225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29226 }
29227 arg2 = reinterpret_cast< wxColour * >(argp2);
29228 if (arg1) (arg1)->colBg = *arg2;
29229
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 PyObject *resultobj = 0;
29239 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29240 wxColour *result = 0 ;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 PyObject *swig_obj[1] ;
29244
29245 if (!args) SWIG_fail;
29246 swig_obj[0] = args;
29247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29250 }
29251 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29252 result = (wxColour *)& ((arg1)->colBg);
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29261 PyObject *obj;
29262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29263 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29264 return SWIG_Py_Void();
29265 }
29266
29267 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29268 return SWIG_Python_InitShadowInstance(args);
29269 }
29270
29271 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj = 0;
29273 wxWindow *arg1 = (wxWindow *) 0 ;
29274 int arg2 = (int) (int)-1 ;
29275 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29276 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29277 wxSize const &arg4_defvalue = wxDefaultSize ;
29278 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29279 long arg5 = (long) 0 ;
29280 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29281 wxString *arg6 = (wxString *) &arg6_defvalue ;
29282 wxWindow *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 int val2 ;
29286 int ecode2 = 0 ;
29287 wxPoint temp3 ;
29288 wxSize temp4 ;
29289 long val5 ;
29290 int ecode5 = 0 ;
29291 bool temp6 = false ;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 PyObject * obj2 = 0 ;
29295 PyObject * obj3 = 0 ;
29296 PyObject * obj4 = 0 ;
29297 PyObject * obj5 = 0 ;
29298 char * kwnames[] = {
29299 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29300 };
29301
29302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29306 }
29307 arg1 = reinterpret_cast< wxWindow * >(argp1);
29308 if (obj1) {
29309 ecode2 = SWIG_AsVal_int(obj1, &val2);
29310 if (!SWIG_IsOK(ecode2)) {
29311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29312 }
29313 arg2 = static_cast< int >(val2);
29314 }
29315 if (obj2) {
29316 {
29317 arg3 = &temp3;
29318 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29319 }
29320 }
29321 if (obj3) {
29322 {
29323 arg4 = &temp4;
29324 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29325 }
29326 }
29327 if (obj4) {
29328 ecode5 = SWIG_AsVal_long(obj4, &val5);
29329 if (!SWIG_IsOK(ecode5)) {
29330 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29331 }
29332 arg5 = static_cast< long >(val5);
29333 }
29334 if (obj5) {
29335 {
29336 arg6 = wxString_in_helper(obj5);
29337 if (arg6 == NULL) SWIG_fail;
29338 temp6 = true;
29339 }
29340 }
29341 {
29342 if (!wxPyCheckForApp()) SWIG_fail;
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29349 {
29350 if (temp6)
29351 delete arg6;
29352 }
29353 return resultobj;
29354 fail:
29355 {
29356 if (temp6)
29357 delete arg6;
29358 }
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 PyObject *resultobj = 0;
29365 wxWindow *result = 0 ;
29366
29367 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29368 {
29369 if (!wxPyCheckForApp()) SWIG_fail;
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 result = (wxWindow *)new wxWindow();
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29383 PyObject *resultobj = 0;
29384 wxWindow *arg1 = (wxWindow *) 0 ;
29385 wxWindow *arg2 = (wxWindow *) 0 ;
29386 int arg3 = (int) (int)-1 ;
29387 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29388 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29389 wxSize const &arg5_defvalue = wxDefaultSize ;
29390 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29391 long arg6 = (long) 0 ;
29392 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29393 wxString *arg7 = (wxString *) &arg7_defvalue ;
29394 bool result;
29395 void *argp1 = 0 ;
29396 int res1 = 0 ;
29397 void *argp2 = 0 ;
29398 int res2 = 0 ;
29399 int val3 ;
29400 int ecode3 = 0 ;
29401 wxPoint temp4 ;
29402 wxSize temp5 ;
29403 long val6 ;
29404 int ecode6 = 0 ;
29405 bool temp7 = false ;
29406 PyObject * obj0 = 0 ;
29407 PyObject * obj1 = 0 ;
29408 PyObject * obj2 = 0 ;
29409 PyObject * obj3 = 0 ;
29410 PyObject * obj4 = 0 ;
29411 PyObject * obj5 = 0 ;
29412 PyObject * obj6 = 0 ;
29413 char * kwnames[] = {
29414 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29415 };
29416
29417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29419 if (!SWIG_IsOK(res1)) {
29420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29421 }
29422 arg1 = reinterpret_cast< wxWindow * >(argp1);
29423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29424 if (!SWIG_IsOK(res2)) {
29425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29426 }
29427 arg2 = reinterpret_cast< wxWindow * >(argp2);
29428 if (obj2) {
29429 ecode3 = SWIG_AsVal_int(obj2, &val3);
29430 if (!SWIG_IsOK(ecode3)) {
29431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29432 }
29433 arg3 = static_cast< int >(val3);
29434 }
29435 if (obj3) {
29436 {
29437 arg4 = &temp4;
29438 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29439 }
29440 }
29441 if (obj4) {
29442 {
29443 arg5 = &temp5;
29444 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29445 }
29446 }
29447 if (obj5) {
29448 ecode6 = SWIG_AsVal_long(obj5, &val6);
29449 if (!SWIG_IsOK(ecode6)) {
29450 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29451 }
29452 arg6 = static_cast< long >(val6);
29453 }
29454 if (obj6) {
29455 {
29456 arg7 = wxString_in_helper(obj6);
29457 if (arg7 == NULL) SWIG_fail;
29458 temp7 = true;
29459 }
29460 }
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 {
29471 if (temp7)
29472 delete arg7;
29473 }
29474 return resultobj;
29475 fail:
29476 {
29477 if (temp7)
29478 delete arg7;
29479 }
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj = 0;
29486 wxWindow *arg1 = (wxWindow *) 0 ;
29487 bool arg2 = (bool) false ;
29488 bool result;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 bool val2 ;
29492 int ecode2 = 0 ;
29493 PyObject * obj0 = 0 ;
29494 PyObject * obj1 = 0 ;
29495 char * kwnames[] = {
29496 (char *) "self",(char *) "force", NULL
29497 };
29498
29499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29501 if (!SWIG_IsOK(res1)) {
29502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29503 }
29504 arg1 = reinterpret_cast< wxWindow * >(argp1);
29505 if (obj1) {
29506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29507 if (!SWIG_IsOK(ecode2)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29509 }
29510 arg2 = static_cast< bool >(val2);
29511 }
29512 {
29513 PyThreadState* __tstate = wxPyBeginAllowThreads();
29514 result = (bool)(arg1)->Close(arg2);
29515 wxPyEndAllowThreads(__tstate);
29516 if (PyErr_Occurred()) SWIG_fail;
29517 }
29518 {
29519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29520 }
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29528 PyObject *resultobj = 0;
29529 wxWindow *arg1 = (wxWindow *) 0 ;
29530 bool result;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 PyObject *swig_obj[1] ;
29534
29535 if (!args) SWIG_fail;
29536 swig_obj[0] = args;
29537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29540 }
29541 arg1 = reinterpret_cast< wxWindow * >(argp1);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = (bool)(arg1)->Destroy();
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 {
29549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29550 }
29551 return resultobj;
29552 fail:
29553 return NULL;
29554 }
29555
29556
29557 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29558 PyObject *resultobj = 0;
29559 wxWindow *arg1 = (wxWindow *) 0 ;
29560 bool result;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 PyObject *swig_obj[1] ;
29564
29565 if (!args) SWIG_fail;
29566 swig_obj[0] = args;
29567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29570 }
29571 arg1 = reinterpret_cast< wxWindow * >(argp1);
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (bool)(arg1)->DestroyChildren();
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 {
29579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29580 }
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29588 PyObject *resultobj = 0;
29589 wxWindow *arg1 = (wxWindow *) 0 ;
29590 bool result;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 PyObject *swig_obj[1] ;
29594
29595 if (!args) SWIG_fail;
29596 swig_obj[0] = args;
29597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29598 if (!SWIG_IsOK(res1)) {
29599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29600 }
29601 arg1 = reinterpret_cast< wxWindow * >(argp1);
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29605 wxPyEndAllowThreads(__tstate);
29606 if (PyErr_Occurred()) SWIG_fail;
29607 }
29608 {
29609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29610 }
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = 0;
29619 wxWindow *arg1 = (wxWindow *) 0 ;
29620 wxString *arg2 = 0 ;
29621 void *argp1 = 0 ;
29622 int res1 = 0 ;
29623 bool temp2 = false ;
29624 PyObject * obj0 = 0 ;
29625 PyObject * obj1 = 0 ;
29626 char * kwnames[] = {
29627 (char *) "self",(char *) "label", NULL
29628 };
29629
29630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29634 }
29635 arg1 = reinterpret_cast< wxWindow * >(argp1);
29636 {
29637 arg2 = wxString_in_helper(obj1);
29638 if (arg2 == NULL) SWIG_fail;
29639 temp2 = true;
29640 }
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 (arg1)->SetLabel((wxString const &)*arg2);
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 resultobj = SWIG_Py_Void();
29648 {
29649 if (temp2)
29650 delete arg2;
29651 }
29652 return resultobj;
29653 fail:
29654 {
29655 if (temp2)
29656 delete arg2;
29657 }
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29663 PyObject *resultobj = 0;
29664 wxWindow *arg1 = (wxWindow *) 0 ;
29665 wxString result;
29666 void *argp1 = 0 ;
29667 int res1 = 0 ;
29668 PyObject *swig_obj[1] ;
29669
29670 if (!args) SWIG_fail;
29671 swig_obj[0] = args;
29672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29675 }
29676 arg1 = reinterpret_cast< wxWindow * >(argp1);
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = ((wxWindow const *)arg1)->GetLabel();
29680 wxPyEndAllowThreads(__tstate);
29681 if (PyErr_Occurred()) SWIG_fail;
29682 }
29683 {
29684 #if wxUSE_UNICODE
29685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29686 #else
29687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29688 #endif
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj = 0;
29698 wxWindow *arg1 = (wxWindow *) 0 ;
29699 wxString *arg2 = 0 ;
29700 void *argp1 = 0 ;
29701 int res1 = 0 ;
29702 bool temp2 = false ;
29703 PyObject * obj0 = 0 ;
29704 PyObject * obj1 = 0 ;
29705 char * kwnames[] = {
29706 (char *) "self",(char *) "name", NULL
29707 };
29708
29709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29711 if (!SWIG_IsOK(res1)) {
29712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29713 }
29714 arg1 = reinterpret_cast< wxWindow * >(argp1);
29715 {
29716 arg2 = wxString_in_helper(obj1);
29717 if (arg2 == NULL) SWIG_fail;
29718 temp2 = true;
29719 }
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 (arg1)->SetName((wxString const &)*arg2);
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 resultobj = SWIG_Py_Void();
29727 {
29728 if (temp2)
29729 delete arg2;
29730 }
29731 return resultobj;
29732 fail:
29733 {
29734 if (temp2)
29735 delete arg2;
29736 }
29737 return NULL;
29738 }
29739
29740
29741 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29742 PyObject *resultobj = 0;
29743 wxWindow *arg1 = (wxWindow *) 0 ;
29744 wxString result;
29745 void *argp1 = 0 ;
29746 int res1 = 0 ;
29747 PyObject *swig_obj[1] ;
29748
29749 if (!args) SWIG_fail;
29750 swig_obj[0] = args;
29751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29752 if (!SWIG_IsOK(res1)) {
29753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29754 }
29755 arg1 = reinterpret_cast< wxWindow * >(argp1);
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 result = ((wxWindow const *)arg1)->GetName();
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 {
29763 #if wxUSE_UNICODE
29764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29765 #else
29766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29767 #endif
29768 }
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29776 PyObject *resultobj = 0;
29777 wxWindow *arg1 = (wxWindow *) 0 ;
29778 wxWindowVariant arg2 ;
29779 void *argp1 = 0 ;
29780 int res1 = 0 ;
29781 int val2 ;
29782 int ecode2 = 0 ;
29783 PyObject * obj0 = 0 ;
29784 PyObject * obj1 = 0 ;
29785 char * kwnames[] = {
29786 (char *) "self",(char *) "variant", NULL
29787 };
29788
29789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29791 if (!SWIG_IsOK(res1)) {
29792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29793 }
29794 arg1 = reinterpret_cast< wxWindow * >(argp1);
29795 ecode2 = SWIG_AsVal_int(obj1, &val2);
29796 if (!SWIG_IsOK(ecode2)) {
29797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29798 }
29799 arg2 = static_cast< wxWindowVariant >(val2);
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 (arg1)->SetWindowVariant(arg2);
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 resultobj = SWIG_Py_Void();
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29814 PyObject *resultobj = 0;
29815 wxWindow *arg1 = (wxWindow *) 0 ;
29816 wxWindowVariant result;
29817 void *argp1 = 0 ;
29818 int res1 = 0 ;
29819 PyObject *swig_obj[1] ;
29820
29821 if (!args) SWIG_fail;
29822 swig_obj[0] = args;
29823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29824 if (!SWIG_IsOK(res1)) {
29825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29826 }
29827 arg1 = reinterpret_cast< wxWindow * >(argp1);
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 resultobj = SWIG_From_int(static_cast< int >(result));
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29842 PyObject *resultobj = 0;
29843 wxWindow *arg1 = (wxWindow *) 0 ;
29844 int arg2 ;
29845 void *argp1 = 0 ;
29846 int res1 = 0 ;
29847 int val2 ;
29848 int ecode2 = 0 ;
29849 PyObject * obj0 = 0 ;
29850 PyObject * obj1 = 0 ;
29851 char * kwnames[] = {
29852 (char *) "self",(char *) "winid", NULL
29853 };
29854
29855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29857 if (!SWIG_IsOK(res1)) {
29858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29859 }
29860 arg1 = reinterpret_cast< wxWindow * >(argp1);
29861 ecode2 = SWIG_AsVal_int(obj1, &val2);
29862 if (!SWIG_IsOK(ecode2)) {
29863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29864 }
29865 arg2 = static_cast< int >(val2);
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 (arg1)->SetId(arg2);
29869 wxPyEndAllowThreads(__tstate);
29870 if (PyErr_Occurred()) SWIG_fail;
29871 }
29872 resultobj = SWIG_Py_Void();
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29880 PyObject *resultobj = 0;
29881 wxWindow *arg1 = (wxWindow *) 0 ;
29882 int result;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 PyObject *swig_obj[1] ;
29886
29887 if (!args) SWIG_fail;
29888 swig_obj[0] = args;
29889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29890 if (!SWIG_IsOK(res1)) {
29891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29892 }
29893 arg1 = reinterpret_cast< wxWindow * >(argp1);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 result = (int)((wxWindow const *)arg1)->GetId();
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_From_int(static_cast< int >(result));
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 int result;
29910
29911 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (int)wxWindow::NewControlId();
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_From_int(static_cast< int >(result));
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 int arg1 ;
29928 int result;
29929 int val1 ;
29930 int ecode1 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 char * kwnames[] = {
29933 (char *) "winid", NULL
29934 };
29935
29936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29937 ecode1 = SWIG_AsVal_int(obj0, &val1);
29938 if (!SWIG_IsOK(ecode1)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29940 }
29941 arg1 = static_cast< int >(val1);
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (int)wxWindow::NextControlId(arg1);
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_From_int(static_cast< int >(result));
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 int arg1 ;
29958 int result;
29959 int val1 ;
29960 int ecode1 = 0 ;
29961 PyObject * obj0 = 0 ;
29962 char * kwnames[] = {
29963 (char *) "winid", NULL
29964 };
29965
29966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29967 ecode1 = SWIG_AsVal_int(obj0, &val1);
29968 if (!SWIG_IsOK(ecode1)) {
29969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29970 }
29971 arg1 = static_cast< int >(val1);
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (int)wxWindow::PrevControlId(arg1);
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 resultobj = SWIG_From_int(static_cast< int >(result));
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj = 0;
29987 wxWindow *arg1 = (wxWindow *) 0 ;
29988 wxSize *arg2 = 0 ;
29989 void *argp1 = 0 ;
29990 int res1 = 0 ;
29991 wxSize temp2 ;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 char * kwnames[] = {
29995 (char *) "self",(char *) "size", NULL
29996 };
29997
29998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
29999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30000 if (!SWIG_IsOK(res1)) {
30001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30002 }
30003 arg1 = reinterpret_cast< wxWindow * >(argp1);
30004 {
30005 arg2 = &temp2;
30006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30007 }
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 (arg1)->SetSize((wxSize const &)*arg2);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_Py_Void();
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = 0;
30023 wxWindow *arg1 = (wxWindow *) 0 ;
30024 int arg2 ;
30025 int arg3 ;
30026 int arg4 ;
30027 int arg5 ;
30028 int arg6 = (int) wxSIZE_AUTO ;
30029 void *argp1 = 0 ;
30030 int res1 = 0 ;
30031 int val2 ;
30032 int ecode2 = 0 ;
30033 int val3 ;
30034 int ecode3 = 0 ;
30035 int val4 ;
30036 int ecode4 = 0 ;
30037 int val5 ;
30038 int ecode5 = 0 ;
30039 int val6 ;
30040 int ecode6 = 0 ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 PyObject * obj2 = 0 ;
30044 PyObject * obj3 = 0 ;
30045 PyObject * obj4 = 0 ;
30046 PyObject * obj5 = 0 ;
30047 char * kwnames[] = {
30048 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30049 };
30050
30051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30055 }
30056 arg1 = reinterpret_cast< wxWindow * >(argp1);
30057 ecode2 = SWIG_AsVal_int(obj1, &val2);
30058 if (!SWIG_IsOK(ecode2)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30060 }
30061 arg2 = static_cast< int >(val2);
30062 ecode3 = SWIG_AsVal_int(obj2, &val3);
30063 if (!SWIG_IsOK(ecode3)) {
30064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30065 }
30066 arg3 = static_cast< int >(val3);
30067 ecode4 = SWIG_AsVal_int(obj3, &val4);
30068 if (!SWIG_IsOK(ecode4)) {
30069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30070 }
30071 arg4 = static_cast< int >(val4);
30072 ecode5 = SWIG_AsVal_int(obj4, &val5);
30073 if (!SWIG_IsOK(ecode5)) {
30074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30075 }
30076 arg5 = static_cast< int >(val5);
30077 if (obj5) {
30078 ecode6 = SWIG_AsVal_int(obj5, &val6);
30079 if (!SWIG_IsOK(ecode6)) {
30080 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30081 }
30082 arg6 = static_cast< int >(val6);
30083 }
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 resultobj = SWIG_Py_Void();
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = 0;
30099 wxWindow *arg1 = (wxWindow *) 0 ;
30100 wxRect *arg2 = 0 ;
30101 int arg3 = (int) wxSIZE_AUTO ;
30102 void *argp1 = 0 ;
30103 int res1 = 0 ;
30104 wxRect temp2 ;
30105 int val3 ;
30106 int ecode3 = 0 ;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 PyObject * obj2 = 0 ;
30110 char * kwnames[] = {
30111 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30112 };
30113
30114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30116 if (!SWIG_IsOK(res1)) {
30117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30118 }
30119 arg1 = reinterpret_cast< wxWindow * >(argp1);
30120 {
30121 arg2 = &temp2;
30122 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30123 }
30124 if (obj2) {
30125 ecode3 = SWIG_AsVal_int(obj2, &val3);
30126 if (!SWIG_IsOK(ecode3)) {
30127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30128 }
30129 arg3 = static_cast< int >(val3);
30130 }
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 resultobj = SWIG_Py_Void();
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30145 PyObject *resultobj = 0;
30146 wxWindow *arg1 = (wxWindow *) 0 ;
30147 int arg2 ;
30148 int arg3 ;
30149 void *argp1 = 0 ;
30150 int res1 = 0 ;
30151 int val2 ;
30152 int ecode2 = 0 ;
30153 int val3 ;
30154 int ecode3 = 0 ;
30155 PyObject * obj0 = 0 ;
30156 PyObject * obj1 = 0 ;
30157 PyObject * obj2 = 0 ;
30158 char * kwnames[] = {
30159 (char *) "self",(char *) "width",(char *) "height", NULL
30160 };
30161
30162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30164 if (!SWIG_IsOK(res1)) {
30165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30166 }
30167 arg1 = reinterpret_cast< wxWindow * >(argp1);
30168 ecode2 = SWIG_AsVal_int(obj1, &val2);
30169 if (!SWIG_IsOK(ecode2)) {
30170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30171 }
30172 arg2 = static_cast< int >(val2);
30173 ecode3 = SWIG_AsVal_int(obj2, &val3);
30174 if (!SWIG_IsOK(ecode3)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30176 }
30177 arg3 = static_cast< int >(val3);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 (arg1)->SetSize(arg2,arg3);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_Py_Void();
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxPoint *arg2 = 0 ;
30195 int arg3 = (int) wxSIZE_USE_EXISTING ;
30196 void *argp1 = 0 ;
30197 int res1 = 0 ;
30198 wxPoint temp2 ;
30199 int val3 ;
30200 int ecode3 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 PyObject * obj2 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "pt",(char *) "flags", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30212 }
30213 arg1 = reinterpret_cast< wxWindow * >(argp1);
30214 {
30215 arg2 = &temp2;
30216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30217 }
30218 if (obj2) {
30219 ecode3 = SWIG_AsVal_int(obj2, &val3);
30220 if (!SWIG_IsOK(ecode3)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30222 }
30223 arg3 = static_cast< int >(val3);
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 (arg1)->Move((wxPoint const &)*arg2,arg3);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_Py_Void();
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj = 0;
30240 wxWindow *arg1 = (wxWindow *) 0 ;
30241 int arg2 ;
30242 int arg3 ;
30243 int arg4 = (int) wxSIZE_USE_EXISTING ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 int val2 ;
30247 int ecode2 = 0 ;
30248 int val3 ;
30249 int ecode3 = 0 ;
30250 int val4 ;
30251 int ecode4 = 0 ;
30252 PyObject * obj0 = 0 ;
30253 PyObject * obj1 = 0 ;
30254 PyObject * obj2 = 0 ;
30255 PyObject * obj3 = 0 ;
30256 char * kwnames[] = {
30257 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30258 };
30259
30260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30264 }
30265 arg1 = reinterpret_cast< wxWindow * >(argp1);
30266 ecode2 = SWIG_AsVal_int(obj1, &val2);
30267 if (!SWIG_IsOK(ecode2)) {
30268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30269 }
30270 arg2 = static_cast< int >(val2);
30271 ecode3 = SWIG_AsVal_int(obj2, &val3);
30272 if (!SWIG_IsOK(ecode3)) {
30273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30274 }
30275 arg3 = static_cast< int >(val3);
30276 if (obj3) {
30277 ecode4 = SWIG_AsVal_int(obj3, &val4);
30278 if (!SWIG_IsOK(ecode4)) {
30279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30280 }
30281 arg4 = static_cast< int >(val4);
30282 }
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 (arg1)->Move(arg2,arg3,arg4);
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 resultobj = SWIG_Py_Void();
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30297 PyObject *resultobj = 0;
30298 wxWindow *arg1 = (wxWindow *) 0 ;
30299 wxSize const &arg2_defvalue = wxDefaultSize ;
30300 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30301 void *argp1 = 0 ;
30302 int res1 = 0 ;
30303 wxSize temp2 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "size", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30314 }
30315 arg1 = reinterpret_cast< wxWindow * >(argp1);
30316 if (obj1) {
30317 {
30318 arg2 = &temp2;
30319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30320 }
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 resultobj = SWIG_Py_Void();
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30336 PyObject *resultobj = 0;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 PyObject *swig_obj[1] ;
30341
30342 if (!args) SWIG_fail;
30343 swig_obj[0] = args;
30344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30345 if (!SWIG_IsOK(res1)) {
30346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30347 }
30348 arg1 = reinterpret_cast< wxWindow * >(argp1);
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->Raise();
30352 wxPyEndAllowThreads(__tstate);
30353 if (PyErr_Occurred()) SWIG_fail;
30354 }
30355 resultobj = SWIG_Py_Void();
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 wxWindow *arg1 = (wxWindow *) 0 ;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 PyObject *swig_obj[1] ;
30368
30369 if (!args) SWIG_fail;
30370 swig_obj[0] = args;
30371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30372 if (!SWIG_IsOK(res1)) {
30373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30374 }
30375 arg1 = reinterpret_cast< wxWindow * >(argp1);
30376 {
30377 PyThreadState* __tstate = wxPyBeginAllowThreads();
30378 (arg1)->Lower();
30379 wxPyEndAllowThreads(__tstate);
30380 if (PyErr_Occurred()) SWIG_fail;
30381 }
30382 resultobj = SWIG_Py_Void();
30383 return resultobj;
30384 fail:
30385 return NULL;
30386 }
30387
30388
30389 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj = 0;
30391 wxWindow *arg1 = (wxWindow *) 0 ;
30392 wxSize *arg2 = 0 ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 wxSize temp2 ;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 char * kwnames[] = {
30399 (char *) "self",(char *) "size", NULL
30400 };
30401
30402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30404 if (!SWIG_IsOK(res1)) {
30405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30406 }
30407 arg1 = reinterpret_cast< wxWindow * >(argp1);
30408 {
30409 arg2 = &temp2;
30410 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30411 }
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 (arg1)->SetClientSize((wxSize const &)*arg2);
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 resultobj = SWIG_Py_Void();
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30426 PyObject *resultobj = 0;
30427 wxWindow *arg1 = (wxWindow *) 0 ;
30428 int arg2 ;
30429 int arg3 ;
30430 void *argp1 = 0 ;
30431 int res1 = 0 ;
30432 int val2 ;
30433 int ecode2 = 0 ;
30434 int val3 ;
30435 int ecode3 = 0 ;
30436 PyObject * obj0 = 0 ;
30437 PyObject * obj1 = 0 ;
30438 PyObject * obj2 = 0 ;
30439 char * kwnames[] = {
30440 (char *) "self",(char *) "width",(char *) "height", NULL
30441 };
30442
30443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30447 }
30448 arg1 = reinterpret_cast< wxWindow * >(argp1);
30449 ecode2 = SWIG_AsVal_int(obj1, &val2);
30450 if (!SWIG_IsOK(ecode2)) {
30451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30452 }
30453 arg2 = static_cast< int >(val2);
30454 ecode3 = SWIG_AsVal_int(obj2, &val3);
30455 if (!SWIG_IsOK(ecode3)) {
30456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30457 }
30458 arg3 = static_cast< int >(val3);
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 (arg1)->SetClientSize(arg2,arg3);
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_Py_Void();
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj = 0;
30474 wxWindow *arg1 = (wxWindow *) 0 ;
30475 wxRect *arg2 = 0 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 wxRect temp2 ;
30479 PyObject * obj0 = 0 ;
30480 PyObject * obj1 = 0 ;
30481 char * kwnames[] = {
30482 (char *) "self",(char *) "rect", NULL
30483 };
30484
30485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30487 if (!SWIG_IsOK(res1)) {
30488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30489 }
30490 arg1 = reinterpret_cast< wxWindow * >(argp1);
30491 {
30492 arg2 = &temp2;
30493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30494 }
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 (arg1)->SetClientSize((wxRect const &)*arg2);
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_Py_Void();
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30509 PyObject *resultobj = 0;
30510 wxWindow *arg1 = (wxWindow *) 0 ;
30511 wxPoint result;
30512 void *argp1 = 0 ;
30513 int res1 = 0 ;
30514 PyObject *swig_obj[1] ;
30515
30516 if (!args) SWIG_fail;
30517 swig_obj[0] = args;
30518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30519 if (!SWIG_IsOK(res1)) {
30520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30521 }
30522 arg1 = reinterpret_cast< wxWindow * >(argp1);
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 result = ((wxWindow const *)arg1)->GetPosition();
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30537 PyObject *resultobj = 0;
30538 wxWindow *arg1 = (wxWindow *) 0 ;
30539 int *arg2 = (int *) 0 ;
30540 int *arg3 = (int *) 0 ;
30541 void *argp1 = 0 ;
30542 int res1 = 0 ;
30543 int temp2 ;
30544 int res2 = SWIG_TMPOBJ ;
30545 int temp3 ;
30546 int res3 = SWIG_TMPOBJ ;
30547 PyObject *swig_obj[1] ;
30548
30549 arg2 = &temp2;
30550 arg3 = &temp3;
30551 if (!args) SWIG_fail;
30552 swig_obj[0] = args;
30553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30554 if (!SWIG_IsOK(res1)) {
30555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30556 }
30557 arg1 = reinterpret_cast< wxWindow * >(argp1);
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 resultobj = SWIG_Py_Void();
30565 if (SWIG_IsTmpObj(res2)) {
30566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30567 } else {
30568 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30570 }
30571 if (SWIG_IsTmpObj(res3)) {
30572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30573 } else {
30574 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30576 }
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxWindow *arg1 = (wxWindow *) 0 ;
30586 wxPoint result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30596 }
30597 arg1 = reinterpret_cast< wxWindow * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = ((wxWindow const *)arg1)->GetScreenPosition();
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30612 PyObject *resultobj = 0;
30613 wxWindow *arg1 = (wxWindow *) 0 ;
30614 int *arg2 = (int *) 0 ;
30615 int *arg3 = (int *) 0 ;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 int temp2 ;
30619 int res2 = SWIG_TMPOBJ ;
30620 int temp3 ;
30621 int res3 = SWIG_TMPOBJ ;
30622 PyObject *swig_obj[1] ;
30623
30624 arg2 = &temp2;
30625 arg3 = &temp3;
30626 if (!args) SWIG_fail;
30627 swig_obj[0] = args;
30628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30631 }
30632 arg1 = reinterpret_cast< wxWindow * >(argp1);
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_Py_Void();
30640 if (SWIG_IsTmpObj(res2)) {
30641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30642 } else {
30643 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30645 }
30646 if (SWIG_IsTmpObj(res3)) {
30647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30648 } else {
30649 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30651 }
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 PyObject *resultobj = 0;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxRect result;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 PyObject *swig_obj[1] ;
30665
30666 if (!args) SWIG_fail;
30667 swig_obj[0] = args;
30668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30669 if (!SWIG_IsOK(res1)) {
30670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30671 }
30672 arg1 = reinterpret_cast< wxWindow * >(argp1);
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = ((wxWindow const *)arg1)->GetScreenRect();
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 wxSize result;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 PyObject *swig_obj[1] ;
30693
30694 if (!args) SWIG_fail;
30695 swig_obj[0] = args;
30696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30699 }
30700 arg1 = reinterpret_cast< wxWindow * >(argp1);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = ((wxWindow const *)arg1)->GetSize();
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30715 PyObject *resultobj = 0;
30716 wxWindow *arg1 = (wxWindow *) 0 ;
30717 int *arg2 = (int *) 0 ;
30718 int *arg3 = (int *) 0 ;
30719 void *argp1 = 0 ;
30720 int res1 = 0 ;
30721 int temp2 ;
30722 int res2 = SWIG_TMPOBJ ;
30723 int temp3 ;
30724 int res3 = SWIG_TMPOBJ ;
30725 PyObject *swig_obj[1] ;
30726
30727 arg2 = &temp2;
30728 arg3 = &temp3;
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_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_Py_Void();
30743 if (SWIG_IsTmpObj(res2)) {
30744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30745 } else {
30746 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30748 }
30749 if (SWIG_IsTmpObj(res3)) {
30750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30751 } else {
30752 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30762 PyObject *resultobj = 0;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 wxRect result;
30765 void *argp1 = 0 ;
30766 int res1 = 0 ;
30767 PyObject *swig_obj[1] ;
30768
30769 if (!args) SWIG_fail;
30770 swig_obj[0] = args;
30771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30772 if (!SWIG_IsOK(res1)) {
30773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30774 }
30775 arg1 = reinterpret_cast< wxWindow * >(argp1);
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = ((wxWindow const *)arg1)->GetRect();
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30790 PyObject *resultobj = 0;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxSize result;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 PyObject *swig_obj[1] ;
30796
30797 if (!args) SWIG_fail;
30798 swig_obj[0] = args;
30799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30800 if (!SWIG_IsOK(res1)) {
30801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30802 }
30803 arg1 = reinterpret_cast< wxWindow * >(argp1);
30804 {
30805 PyThreadState* __tstate = wxPyBeginAllowThreads();
30806 result = ((wxWindow const *)arg1)->GetClientSize();
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30818 PyObject *resultobj = 0;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 int *arg2 = (int *) 0 ;
30821 int *arg3 = (int *) 0 ;
30822 void *argp1 = 0 ;
30823 int res1 = 0 ;
30824 int temp2 ;
30825 int res2 = SWIG_TMPOBJ ;
30826 int temp3 ;
30827 int res3 = SWIG_TMPOBJ ;
30828 PyObject *swig_obj[1] ;
30829
30830 arg2 = &temp2;
30831 arg3 = &temp3;
30832 if (!args) SWIG_fail;
30833 swig_obj[0] = args;
30834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30835 if (!SWIG_IsOK(res1)) {
30836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30837 }
30838 arg1 = reinterpret_cast< wxWindow * >(argp1);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 resultobj = SWIG_Py_Void();
30846 if (SWIG_IsTmpObj(res2)) {
30847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30848 } else {
30849 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30851 }
30852 if (SWIG_IsTmpObj(res3)) {
30853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30854 } else {
30855 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 wxPoint result;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 PyObject *swig_obj[1] ;
30871
30872 if (!args) SWIG_fail;
30873 swig_obj[0] = args;
30874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30875 if (!SWIG_IsOK(res1)) {
30876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30877 }
30878 arg1 = reinterpret_cast< wxWindow * >(argp1);
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxWindow *arg1 = (wxWindow *) 0 ;
30895 wxRect result;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 PyObject *swig_obj[1] ;
30899
30900 if (!args) SWIG_fail;
30901 swig_obj[0] = args;
30902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30905 }
30906 arg1 = reinterpret_cast< wxWindow * >(argp1);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = ((wxWindow const *)arg1)->GetClientRect();
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30921 PyObject *resultobj = 0;
30922 wxWindow *arg1 = (wxWindow *) 0 ;
30923 wxSize result;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 PyObject *swig_obj[1] ;
30927
30928 if (!args) SWIG_fail;
30929 swig_obj[0] = args;
30930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30931 if (!SWIG_IsOK(res1)) {
30932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30933 }
30934 arg1 = reinterpret_cast< wxWindow * >(argp1);
30935 {
30936 PyThreadState* __tstate = wxPyBeginAllowThreads();
30937 result = ((wxWindow const *)arg1)->GetBestSize();
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30949 PyObject *resultobj = 0;
30950 wxWindow *arg1 = (wxWindow *) 0 ;
30951 int *arg2 = (int *) 0 ;
30952 int *arg3 = (int *) 0 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 int temp2 ;
30956 int res2 = SWIG_TMPOBJ ;
30957 int temp3 ;
30958 int res3 = SWIG_TMPOBJ ;
30959 PyObject *swig_obj[1] ;
30960
30961 arg2 = &temp2;
30962 arg3 = &temp3;
30963 if (!args) SWIG_fail;
30964 swig_obj[0] = args;
30965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30968 }
30969 arg1 = reinterpret_cast< wxWindow * >(argp1);
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 resultobj = SWIG_Py_Void();
30977 if (SWIG_IsTmpObj(res2)) {
30978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30979 } else {
30980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30982 }
30983 if (SWIG_IsTmpObj(res3)) {
30984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30985 } else {
30986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30988 }
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30996 PyObject *resultobj = 0;
30997 wxWindow *arg1 = (wxWindow *) 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31007 }
31008 arg1 = reinterpret_cast< wxWindow * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 (arg1)->InvalidateBestSize();
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_Py_Void();
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj = 0;
31024 wxWindow *arg1 = (wxWindow *) 0 ;
31025 wxSize *arg2 = 0 ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 wxSize temp2 ;
31029 PyObject * obj0 = 0 ;
31030 PyObject * obj1 = 0 ;
31031 char * kwnames[] = {
31032 (char *) "self",(char *) "size", NULL
31033 };
31034
31035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31037 if (!SWIG_IsOK(res1)) {
31038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31039 }
31040 arg1 = reinterpret_cast< wxWindow * >(argp1);
31041 {
31042 arg2 = &temp2;
31043 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31044 }
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
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_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31059 PyObject *resultobj = 0;
31060 wxWindow *arg1 = (wxWindow *) 0 ;
31061 wxSize result;
31062 void *argp1 = 0 ;
31063 int res1 = 0 ;
31064 PyObject *swig_obj[1] ;
31065
31066 if (!args) SWIG_fail;
31067 swig_obj[0] = args;
31068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31071 }
31072 arg1 = reinterpret_cast< wxWindow * >(argp1);
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31087 PyObject *resultobj = 0;
31088 wxWindow *arg1 = (wxWindow *) 0 ;
31089 wxSize result;
31090 void *argp1 = 0 ;
31091 int res1 = 0 ;
31092 PyObject *swig_obj[1] ;
31093
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31099 }
31100 arg1 = reinterpret_cast< wxWindow * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = 0;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 int arg2 = (int) wxBOTH ;
31118 void *argp1 = 0 ;
31119 int res1 = 0 ;
31120 int val2 ;
31121 int ecode2 = 0 ;
31122 PyObject * obj0 = 0 ;
31123 PyObject * obj1 = 0 ;
31124 char * kwnames[] = {
31125 (char *) "self",(char *) "direction", NULL
31126 };
31127
31128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31130 if (!SWIG_IsOK(res1)) {
31131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31132 }
31133 arg1 = reinterpret_cast< wxWindow * >(argp1);
31134 if (obj1) {
31135 ecode2 = SWIG_AsVal_int(obj1, &val2);
31136 if (!SWIG_IsOK(ecode2)) {
31137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31138 }
31139 arg2 = static_cast< int >(val2);
31140 }
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 (arg1)->Center(arg2);
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 resultobj = SWIG_Py_Void();
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj = 0;
31156 wxWindow *arg1 = (wxWindow *) 0 ;
31157 int arg2 = (int) wxBOTH ;
31158 void *argp1 = 0 ;
31159 int res1 = 0 ;
31160 int val2 ;
31161 int ecode2 = 0 ;
31162 PyObject * obj0 = 0 ;
31163 PyObject * obj1 = 0 ;
31164 char * kwnames[] = {
31165 (char *) "self",(char *) "dir", NULL
31166 };
31167
31168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31170 if (!SWIG_IsOK(res1)) {
31171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31172 }
31173 arg1 = reinterpret_cast< wxWindow * >(argp1);
31174 if (obj1) {
31175 ecode2 = SWIG_AsVal_int(obj1, &val2);
31176 if (!SWIG_IsOK(ecode2)) {
31177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31178 }
31179 arg2 = static_cast< int >(val2);
31180 }
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 (arg1)->CenterOnParent(arg2);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31195 PyObject *resultobj = 0;
31196 wxWindow *arg1 = (wxWindow *) 0 ;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 PyObject *swig_obj[1] ;
31200
31201 if (!args) SWIG_fail;
31202 swig_obj[0] = args;
31203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31204 if (!SWIG_IsOK(res1)) {
31205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31206 }
31207 arg1 = reinterpret_cast< wxWindow * >(argp1);
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 (arg1)->Fit();
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_Py_Void();
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31222 PyObject *resultobj = 0;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 void *argp1 = 0 ;
31225 int res1 = 0 ;
31226 PyObject *swig_obj[1] ;
31227
31228 if (!args) SWIG_fail;
31229 swig_obj[0] = args;
31230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31231 if (!SWIG_IsOK(res1)) {
31232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31233 }
31234 arg1 = reinterpret_cast< wxWindow * >(argp1);
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->FitInside();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 int arg2 ;
31252 int arg3 ;
31253 int arg4 = (int) -1 ;
31254 int arg5 = (int) -1 ;
31255 int arg6 = (int) -1 ;
31256 int arg7 = (int) -1 ;
31257 void *argp1 = 0 ;
31258 int res1 = 0 ;
31259 int val2 ;
31260 int ecode2 = 0 ;
31261 int val3 ;
31262 int ecode3 = 0 ;
31263 int val4 ;
31264 int ecode4 = 0 ;
31265 int val5 ;
31266 int ecode5 = 0 ;
31267 int val6 ;
31268 int ecode6 = 0 ;
31269 int val7 ;
31270 int ecode7 = 0 ;
31271 PyObject * obj0 = 0 ;
31272 PyObject * obj1 = 0 ;
31273 PyObject * obj2 = 0 ;
31274 PyObject * obj3 = 0 ;
31275 PyObject * obj4 = 0 ;
31276 PyObject * obj5 = 0 ;
31277 PyObject * obj6 = 0 ;
31278 char * kwnames[] = {
31279 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31280 };
31281
31282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31284 if (!SWIG_IsOK(res1)) {
31285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31286 }
31287 arg1 = reinterpret_cast< wxWindow * >(argp1);
31288 ecode2 = SWIG_AsVal_int(obj1, &val2);
31289 if (!SWIG_IsOK(ecode2)) {
31290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31291 }
31292 arg2 = static_cast< int >(val2);
31293 ecode3 = SWIG_AsVal_int(obj2, &val3);
31294 if (!SWIG_IsOK(ecode3)) {
31295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31296 }
31297 arg3 = static_cast< int >(val3);
31298 if (obj3) {
31299 ecode4 = SWIG_AsVal_int(obj3, &val4);
31300 if (!SWIG_IsOK(ecode4)) {
31301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31302 }
31303 arg4 = static_cast< int >(val4);
31304 }
31305 if (obj4) {
31306 ecode5 = SWIG_AsVal_int(obj4, &val5);
31307 if (!SWIG_IsOK(ecode5)) {
31308 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31309 }
31310 arg5 = static_cast< int >(val5);
31311 }
31312 if (obj5) {
31313 ecode6 = SWIG_AsVal_int(obj5, &val6);
31314 if (!SWIG_IsOK(ecode6)) {
31315 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31316 }
31317 arg6 = static_cast< int >(val6);
31318 }
31319 if (obj6) {
31320 ecode7 = SWIG_AsVal_int(obj6, &val7);
31321 if (!SWIG_IsOK(ecode7)) {
31322 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31323 }
31324 arg7 = static_cast< int >(val7);
31325 }
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
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_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxWindow *arg1 = (wxWindow *) 0 ;
31342 wxSize *arg2 = 0 ;
31343 wxSize const &arg3_defvalue = wxDefaultSize ;
31344 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31345 wxSize const &arg4_defvalue = wxDefaultSize ;
31346 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31347 void *argp1 = 0 ;
31348 int res1 = 0 ;
31349 wxSize temp2 ;
31350 wxSize temp3 ;
31351 wxSize temp4 ;
31352 PyObject * obj0 = 0 ;
31353 PyObject * obj1 = 0 ;
31354 PyObject * obj2 = 0 ;
31355 PyObject * obj3 = 0 ;
31356 char * kwnames[] = {
31357 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31358 };
31359
31360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31364 }
31365 arg1 = reinterpret_cast< wxWindow * >(argp1);
31366 {
31367 arg2 = &temp2;
31368 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31369 }
31370 if (obj2) {
31371 {
31372 arg3 = &temp3;
31373 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31374 }
31375 }
31376 if (obj3) {
31377 {
31378 arg4 = &temp4;
31379 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31380 }
31381 }
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 resultobj = SWIG_Py_Void();
31389 return resultobj;
31390 fail:
31391 return NULL;
31392 }
31393
31394
31395 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31396 PyObject *resultobj = 0;
31397 wxWindow *arg1 = (wxWindow *) 0 ;
31398 int arg2 ;
31399 int arg3 ;
31400 int arg4 = (int) -1 ;
31401 int arg5 = (int) -1 ;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 int val2 ;
31405 int ecode2 = 0 ;
31406 int val3 ;
31407 int ecode3 = 0 ;
31408 int val4 ;
31409 int ecode4 = 0 ;
31410 int val5 ;
31411 int ecode5 = 0 ;
31412 PyObject * obj0 = 0 ;
31413 PyObject * obj1 = 0 ;
31414 PyObject * obj2 = 0 ;
31415 PyObject * obj3 = 0 ;
31416 PyObject * obj4 = 0 ;
31417 char * kwnames[] = {
31418 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31419 };
31420
31421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31423 if (!SWIG_IsOK(res1)) {
31424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31425 }
31426 arg1 = reinterpret_cast< wxWindow * >(argp1);
31427 ecode2 = SWIG_AsVal_int(obj1, &val2);
31428 if (!SWIG_IsOK(ecode2)) {
31429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31430 }
31431 arg2 = static_cast< int >(val2);
31432 ecode3 = SWIG_AsVal_int(obj2, &val3);
31433 if (!SWIG_IsOK(ecode3)) {
31434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31435 }
31436 arg3 = static_cast< int >(val3);
31437 if (obj3) {
31438 ecode4 = SWIG_AsVal_int(obj3, &val4);
31439 if (!SWIG_IsOK(ecode4)) {
31440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31441 }
31442 arg4 = static_cast< int >(val4);
31443 }
31444 if (obj4) {
31445 ecode5 = SWIG_AsVal_int(obj4, &val5);
31446 if (!SWIG_IsOK(ecode5)) {
31447 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31448 }
31449 arg5 = static_cast< int >(val5);
31450 }
31451 {
31452 PyThreadState* __tstate = wxPyBeginAllowThreads();
31453 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 resultobj = SWIG_Py_Void();
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31465 PyObject *resultobj = 0;
31466 wxWindow *arg1 = (wxWindow *) 0 ;
31467 wxSize *arg2 = 0 ;
31468 wxSize const &arg3_defvalue = wxDefaultSize ;
31469 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31470 void *argp1 = 0 ;
31471 int res1 = 0 ;
31472 wxSize temp2 ;
31473 wxSize temp3 ;
31474 PyObject * obj0 = 0 ;
31475 PyObject * obj1 = 0 ;
31476 PyObject * obj2 = 0 ;
31477 char * kwnames[] = {
31478 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31479 };
31480
31481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31485 }
31486 arg1 = reinterpret_cast< wxWindow * >(argp1);
31487 {
31488 arg2 = &temp2;
31489 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31490 }
31491 if (obj2) {
31492 {
31493 arg3 = &temp3;
31494 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31495 }
31496 }
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 resultobj = SWIG_Py_Void();
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *resultobj = 0;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 wxSize result;
31514 void *argp1 = 0 ;
31515 int res1 = 0 ;
31516 PyObject *swig_obj[1] ;
31517
31518 if (!args) SWIG_fail;
31519 swig_obj[0] = args;
31520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31521 if (!SWIG_IsOK(res1)) {
31522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31523 }
31524 arg1 = reinterpret_cast< wxWindow * >(argp1);
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 result = ((wxWindow const *)arg1)->GetMaxSize();
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 wxSize result;
31542 void *argp1 = 0 ;
31543 int res1 = 0 ;
31544 PyObject *swig_obj[1] ;
31545
31546 if (!args) SWIG_fail;
31547 swig_obj[0] = args;
31548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31549 if (!SWIG_IsOK(res1)) {
31550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31551 }
31552 arg1 = reinterpret_cast< wxWindow * >(argp1);
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = ((wxWindow const *)arg1)->GetMinSize();
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31567 PyObject *resultobj = 0;
31568 wxWindow *arg1 = (wxWindow *) 0 ;
31569 wxSize *arg2 = 0 ;
31570 void *argp1 = 0 ;
31571 int res1 = 0 ;
31572 wxSize temp2 ;
31573 PyObject * obj0 = 0 ;
31574 PyObject * obj1 = 0 ;
31575 char * kwnames[] = {
31576 (char *) "self",(char *) "minSize", NULL
31577 };
31578
31579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31581 if (!SWIG_IsOK(res1)) {
31582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31583 }
31584 arg1 = reinterpret_cast< wxWindow * >(argp1);
31585 {
31586 arg2 = &temp2;
31587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31588 }
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 (arg1)->SetMinSize((wxSize const &)*arg2);
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 resultobj = SWIG_Py_Void();
31596 return resultobj;
31597 fail:
31598 return NULL;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31603 PyObject *resultobj = 0;
31604 wxWindow *arg1 = (wxWindow *) 0 ;
31605 wxSize *arg2 = 0 ;
31606 void *argp1 = 0 ;
31607 int res1 = 0 ;
31608 wxSize temp2 ;
31609 PyObject * obj0 = 0 ;
31610 PyObject * obj1 = 0 ;
31611 char * kwnames[] = {
31612 (char *) "self",(char *) "maxSize", NULL
31613 };
31614
31615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31619 }
31620 arg1 = reinterpret_cast< wxWindow * >(argp1);
31621 {
31622 arg2 = &temp2;
31623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31624 }
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 (arg1)->SetMaxSize((wxSize const &)*arg2);
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_Py_Void();
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31639 PyObject *resultobj = 0;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 int result;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 PyObject *swig_obj[1] ;
31645
31646 if (!args) SWIG_fail;
31647 swig_obj[0] = args;
31648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31651 }
31652 arg1 = reinterpret_cast< wxWindow * >(argp1);
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31656 wxPyEndAllowThreads(__tstate);
31657 if (PyErr_Occurred()) SWIG_fail;
31658 }
31659 resultobj = SWIG_From_int(static_cast< int >(result));
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31667 PyObject *resultobj = 0;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 int result;
31670 void *argp1 = 0 ;
31671 int res1 = 0 ;
31672 PyObject *swig_obj[1] ;
31673
31674 if (!args) SWIG_fail;
31675 swig_obj[0] = args;
31676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31679 }
31680 arg1 = reinterpret_cast< wxWindow * >(argp1);
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 resultobj = SWIG_From_int(static_cast< int >(result));
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31695 PyObject *resultobj = 0;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 int result;
31698 void *argp1 = 0 ;
31699 int res1 = 0 ;
31700 PyObject *swig_obj[1] ;
31701
31702 if (!args) SWIG_fail;
31703 swig_obj[0] = args;
31704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31705 if (!SWIG_IsOK(res1)) {
31706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_From_int(static_cast< int >(result));
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 int result;
31726 void *argp1 = 0 ;
31727 int res1 = 0 ;
31728 PyObject *swig_obj[1] ;
31729
31730 if (!args) SWIG_fail;
31731 swig_obj[0] = args;
31732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31735 }
31736 arg1 = reinterpret_cast< wxWindow * >(argp1);
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_From_int(static_cast< int >(result));
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31751 PyObject *resultobj = 0;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 wxSize *arg2 = 0 ;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 wxSize temp2 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "size", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31767 }
31768 arg1 = reinterpret_cast< wxWindow * >(argp1);
31769 {
31770 arg2 = &temp2;
31771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31772 }
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_Py_Void();
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31787 PyObject *resultobj = 0;
31788 wxWindow *arg1 = (wxWindow *) 0 ;
31789 int arg2 ;
31790 int arg3 ;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 int val2 ;
31794 int ecode2 = 0 ;
31795 int val3 ;
31796 int ecode3 = 0 ;
31797 PyObject * obj0 = 0 ;
31798 PyObject * obj1 = 0 ;
31799 PyObject * obj2 = 0 ;
31800 char * kwnames[] = {
31801 (char *) "self",(char *) "w",(char *) "h", NULL
31802 };
31803
31804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31808 }
31809 arg1 = reinterpret_cast< wxWindow * >(argp1);
31810 ecode2 = SWIG_AsVal_int(obj1, &val2);
31811 if (!SWIG_IsOK(ecode2)) {
31812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31813 }
31814 arg2 = static_cast< int >(val2);
31815 ecode3 = SWIG_AsVal_int(obj2, &val3);
31816 if (!SWIG_IsOK(ecode3)) {
31817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31818 }
31819 arg3 = static_cast< int >(val3);
31820 {
31821 PyThreadState* __tstate = wxPyBeginAllowThreads();
31822 (arg1)->SetVirtualSize(arg2,arg3);
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 resultobj = SWIG_Py_Void();
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31834 PyObject *resultobj = 0;
31835 wxWindow *arg1 = (wxWindow *) 0 ;
31836 wxSize result;
31837 void *argp1 = 0 ;
31838 int res1 = 0 ;
31839 PyObject *swig_obj[1] ;
31840
31841 if (!args) SWIG_fail;
31842 swig_obj[0] = args;
31843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31844 if (!SWIG_IsOK(res1)) {
31845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31846 }
31847 arg1 = reinterpret_cast< wxWindow * >(argp1);
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = ((wxWindow const *)arg1)->GetVirtualSize();
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31862 PyObject *resultobj = 0;
31863 wxWindow *arg1 = (wxWindow *) 0 ;
31864 int *arg2 = (int *) 0 ;
31865 int *arg3 = (int *) 0 ;
31866 void *argp1 = 0 ;
31867 int res1 = 0 ;
31868 int temp2 ;
31869 int res2 = SWIG_TMPOBJ ;
31870 int temp3 ;
31871 int res3 = SWIG_TMPOBJ ;
31872 PyObject *swig_obj[1] ;
31873
31874 arg2 = &temp2;
31875 arg3 = &temp3;
31876 if (!args) SWIG_fail;
31877 swig_obj[0] = args;
31878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31879 if (!SWIG_IsOK(res1)) {
31880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31881 }
31882 arg1 = reinterpret_cast< wxWindow * >(argp1);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_Py_Void();
31890 if (SWIG_IsTmpObj(res2)) {
31891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31892 } else {
31893 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31895 }
31896 if (SWIG_IsTmpObj(res3)) {
31897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31898 } else {
31899 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31901 }
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31909 PyObject *resultobj = 0;
31910 wxWindow *arg1 = (wxWindow *) 0 ;
31911 wxSize result;
31912 void *argp1 = 0 ;
31913 int res1 = 0 ;
31914 PyObject *swig_obj[1] ;
31915
31916 if (!args) SWIG_fail;
31917 swig_obj[0] = args;
31918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31919 if (!SWIG_IsOK(res1)) {
31920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31921 }
31922 arg1 = reinterpret_cast< wxWindow * >(argp1);
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj = 0;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 bool arg2 = (bool) true ;
31940 bool result;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 bool val2 ;
31944 int ecode2 = 0 ;
31945 PyObject * obj0 = 0 ;
31946 PyObject * obj1 = 0 ;
31947 char * kwnames[] = {
31948 (char *) "self",(char *) "show", NULL
31949 };
31950
31951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31953 if (!SWIG_IsOK(res1)) {
31954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31955 }
31956 arg1 = reinterpret_cast< wxWindow * >(argp1);
31957 if (obj1) {
31958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31959 if (!SWIG_IsOK(ecode2)) {
31960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31961 }
31962 arg2 = static_cast< bool >(val2);
31963 }
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (bool)(arg1)->Show(arg2);
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 {
31971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31972 }
31973 return resultobj;
31974 fail:
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *resultobj = 0;
31981 wxWindow *arg1 = (wxWindow *) 0 ;
31982 bool result;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 PyObject *swig_obj[1] ;
31986
31987 if (!args) SWIG_fail;
31988 swig_obj[0] = args;
31989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31990 if (!SWIG_IsOK(res1)) {
31991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31992 }
31993 arg1 = reinterpret_cast< wxWindow * >(argp1);
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (bool)(arg1)->Hide();
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 bool arg2 = (bool) true ;
32013 bool result;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 bool val2 ;
32017 int ecode2 = 0 ;
32018 PyObject * obj0 = 0 ;
32019 PyObject * obj1 = 0 ;
32020 char * kwnames[] = {
32021 (char *) "self",(char *) "enable", NULL
32022 };
32023
32024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32026 if (!SWIG_IsOK(res1)) {
32027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32028 }
32029 arg1 = reinterpret_cast< wxWindow * >(argp1);
32030 if (obj1) {
32031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32032 if (!SWIG_IsOK(ecode2)) {
32033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32034 }
32035 arg2 = static_cast< bool >(val2);
32036 }
32037 {
32038 PyThreadState* __tstate = wxPyBeginAllowThreads();
32039 result = (bool)(arg1)->Enable(arg2);
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 {
32044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32045 }
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053 PyObject *resultobj = 0;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 bool result;
32056 void *argp1 = 0 ;
32057 int res1 = 0 ;
32058 PyObject *swig_obj[1] ;
32059
32060 if (!args) SWIG_fail;
32061 swig_obj[0] = args;
32062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32063 if (!SWIG_IsOK(res1)) {
32064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32065 }
32066 arg1 = reinterpret_cast< wxWindow * >(argp1);
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = (bool)(arg1)->Disable();
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 {
32074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32075 }
32076 return resultobj;
32077 fail:
32078 return NULL;
32079 }
32080
32081
32082 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32083 PyObject *resultobj = 0;
32084 wxWindow *arg1 = (wxWindow *) 0 ;
32085 bool result;
32086 void *argp1 = 0 ;
32087 int res1 = 0 ;
32088 PyObject *swig_obj[1] ;
32089
32090 if (!args) SWIG_fail;
32091 swig_obj[0] = args;
32092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32093 if (!SWIG_IsOK(res1)) {
32094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32095 }
32096 arg1 = reinterpret_cast< wxWindow * >(argp1);
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 result = (bool)((wxWindow const *)arg1)->IsShown();
32100 wxPyEndAllowThreads(__tstate);
32101 if (PyErr_Occurred()) SWIG_fail;
32102 }
32103 {
32104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32105 }
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 wxWindow *arg1 = (wxWindow *) 0 ;
32115 bool result;
32116 void *argp1 = 0 ;
32117 int res1 = 0 ;
32118 PyObject *swig_obj[1] ;
32119
32120 if (!args) SWIG_fail;
32121 swig_obj[0] = args;
32122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32123 if (!SWIG_IsOK(res1)) {
32124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32125 }
32126 arg1 = reinterpret_cast< wxWindow * >(argp1);
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 {
32134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32135 }
32136 return resultobj;
32137 fail:
32138 return NULL;
32139 }
32140
32141
32142 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32143 PyObject *resultobj = 0;
32144 wxWindow *arg1 = (wxWindow *) 0 ;
32145 long arg2 ;
32146 void *argp1 = 0 ;
32147 int res1 = 0 ;
32148 long val2 ;
32149 int ecode2 = 0 ;
32150 PyObject * obj0 = 0 ;
32151 PyObject * obj1 = 0 ;
32152 char * kwnames[] = {
32153 (char *) "self",(char *) "style", NULL
32154 };
32155
32156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32158 if (!SWIG_IsOK(res1)) {
32159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32160 }
32161 arg1 = reinterpret_cast< wxWindow * >(argp1);
32162 ecode2 = SWIG_AsVal_long(obj1, &val2);
32163 if (!SWIG_IsOK(ecode2)) {
32164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32165 }
32166 arg2 = static_cast< long >(val2);
32167 {
32168 PyThreadState* __tstate = wxPyBeginAllowThreads();
32169 (arg1)->SetWindowStyleFlag(arg2);
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 resultobj = SWIG_Py_Void();
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32181 PyObject *resultobj = 0;
32182 wxWindow *arg1 = (wxWindow *) 0 ;
32183 long result;
32184 void *argp1 = 0 ;
32185 int res1 = 0 ;
32186 PyObject *swig_obj[1] ;
32187
32188 if (!args) SWIG_fail;
32189 swig_obj[0] = args;
32190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32191 if (!SWIG_IsOK(res1)) {
32192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32193 }
32194 arg1 = reinterpret_cast< wxWindow * >(argp1);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_From_long(static_cast< long >(result));
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32209 PyObject *resultobj = 0;
32210 wxWindow *arg1 = (wxWindow *) 0 ;
32211 int arg2 ;
32212 bool result;
32213 void *argp1 = 0 ;
32214 int res1 = 0 ;
32215 int val2 ;
32216 int ecode2 = 0 ;
32217 PyObject * obj0 = 0 ;
32218 PyObject * obj1 = 0 ;
32219 char * kwnames[] = {
32220 (char *) "self",(char *) "flag", NULL
32221 };
32222
32223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32225 if (!SWIG_IsOK(res1)) {
32226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32227 }
32228 arg1 = reinterpret_cast< wxWindow * >(argp1);
32229 ecode2 = SWIG_AsVal_int(obj1, &val2);
32230 if (!SWIG_IsOK(ecode2)) {
32231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32232 }
32233 arg2 = static_cast< int >(val2);
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 {
32241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32242 }
32243 return resultobj;
32244 fail:
32245 return NULL;
32246 }
32247
32248
32249 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32250 PyObject *resultobj = 0;
32251 wxWindow *arg1 = (wxWindow *) 0 ;
32252 bool result;
32253 void *argp1 = 0 ;
32254 int res1 = 0 ;
32255 PyObject *swig_obj[1] ;
32256
32257 if (!args) SWIG_fail;
32258 swig_obj[0] = args;
32259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32260 if (!SWIG_IsOK(res1)) {
32261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32262 }
32263 arg1 = reinterpret_cast< wxWindow * >(argp1);
32264 {
32265 PyThreadState* __tstate = wxPyBeginAllowThreads();
32266 result = (bool)((wxWindow const *)arg1)->IsRetained();
32267 wxPyEndAllowThreads(__tstate);
32268 if (PyErr_Occurred()) SWIG_fail;
32269 }
32270 {
32271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32272 }
32273 return resultobj;
32274 fail:
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32280 PyObject *resultobj = 0;
32281 wxWindow *arg1 = (wxWindow *) 0 ;
32282 long arg2 ;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 long val2 ;
32286 int ecode2 = 0 ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 char * kwnames[] = {
32290 (char *) "self",(char *) "exStyle", NULL
32291 };
32292
32293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32297 }
32298 arg1 = reinterpret_cast< wxWindow * >(argp1);
32299 ecode2 = SWIG_AsVal_long(obj1, &val2);
32300 if (!SWIG_IsOK(ecode2)) {
32301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32302 }
32303 arg2 = static_cast< long >(val2);
32304 {
32305 PyThreadState* __tstate = wxPyBeginAllowThreads();
32306 (arg1)->SetExtraStyle(arg2);
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 resultobj = SWIG_Py_Void();
32311 return resultobj;
32312 fail:
32313 return NULL;
32314 }
32315
32316
32317 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318 PyObject *resultobj = 0;
32319 wxWindow *arg1 = (wxWindow *) 0 ;
32320 long result;
32321 void *argp1 = 0 ;
32322 int res1 = 0 ;
32323 PyObject *swig_obj[1] ;
32324
32325 if (!args) SWIG_fail;
32326 swig_obj[0] = args;
32327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32328 if (!SWIG_IsOK(res1)) {
32329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32330 }
32331 arg1 = reinterpret_cast< wxWindow * >(argp1);
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 resultobj = SWIG_From_long(static_cast< long >(result));
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32346 PyObject *resultobj = 0;
32347 wxWindow *arg1 = (wxWindow *) 0 ;
32348 bool arg2 = (bool) true ;
32349 void *argp1 = 0 ;
32350 int res1 = 0 ;
32351 bool val2 ;
32352 int ecode2 = 0 ;
32353 PyObject * obj0 = 0 ;
32354 PyObject * obj1 = 0 ;
32355 char * kwnames[] = {
32356 (char *) "self",(char *) "modal", NULL
32357 };
32358
32359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32361 if (!SWIG_IsOK(res1)) {
32362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32363 }
32364 arg1 = reinterpret_cast< wxWindow * >(argp1);
32365 if (obj1) {
32366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32367 if (!SWIG_IsOK(ecode2)) {
32368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32369 }
32370 arg2 = static_cast< bool >(val2);
32371 }
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
32374 (arg1)->MakeModal(arg2);
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 resultobj = SWIG_Py_Void();
32379 return resultobj;
32380 fail:
32381 return NULL;
32382 }
32383
32384
32385 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32386 PyObject *resultobj = 0;
32387 wxWindow *arg1 = (wxWindow *) 0 ;
32388 bool arg2 ;
32389 void *argp1 = 0 ;
32390 int res1 = 0 ;
32391 bool val2 ;
32392 int ecode2 = 0 ;
32393 PyObject * obj0 = 0 ;
32394 PyObject * obj1 = 0 ;
32395 char * kwnames[] = {
32396 (char *) "self",(char *) "enableTheme", NULL
32397 };
32398
32399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32401 if (!SWIG_IsOK(res1)) {
32402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32403 }
32404 arg1 = reinterpret_cast< wxWindow * >(argp1);
32405 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32406 if (!SWIG_IsOK(ecode2)) {
32407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32408 }
32409 arg2 = static_cast< bool >(val2);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 (arg1)->SetThemeEnabled(arg2);
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 resultobj = SWIG_Py_Void();
32417 return resultobj;
32418 fail:
32419 return NULL;
32420 }
32421
32422
32423 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32424 PyObject *resultobj = 0;
32425 wxWindow *arg1 = (wxWindow *) 0 ;
32426 bool result;
32427 void *argp1 = 0 ;
32428 int res1 = 0 ;
32429 PyObject *swig_obj[1] ;
32430
32431 if (!args) SWIG_fail;
32432 swig_obj[0] = args;
32433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32434 if (!SWIG_IsOK(res1)) {
32435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32436 }
32437 arg1 = reinterpret_cast< wxWindow * >(argp1);
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 {
32445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32446 }
32447 return resultobj;
32448 fail:
32449 return NULL;
32450 }
32451
32452
32453 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32454 PyObject *resultobj = 0;
32455 wxWindow *arg1 = (wxWindow *) 0 ;
32456 void *argp1 = 0 ;
32457 int res1 = 0 ;
32458 PyObject *swig_obj[1] ;
32459
32460 if (!args) SWIG_fail;
32461 swig_obj[0] = args;
32462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32463 if (!SWIG_IsOK(res1)) {
32464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32465 }
32466 arg1 = reinterpret_cast< wxWindow * >(argp1);
32467 {
32468 PyThreadState* __tstate = wxPyBeginAllowThreads();
32469 (arg1)->SetFocus();
32470 wxPyEndAllowThreads(__tstate);
32471 if (PyErr_Occurred()) SWIG_fail;
32472 }
32473 resultobj = SWIG_Py_Void();
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32481 PyObject *resultobj = 0;
32482 wxWindow *arg1 = (wxWindow *) 0 ;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 PyObject *swig_obj[1] ;
32486
32487 if (!args) SWIG_fail;
32488 swig_obj[0] = args;
32489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32490 if (!SWIG_IsOK(res1)) {
32491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32492 }
32493 arg1 = reinterpret_cast< wxWindow * >(argp1);
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 (arg1)->SetFocusFromKbd();
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 resultobj = SWIG_Py_Void();
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *resultobj = 0;
32509 wxWindow *result = 0 ;
32510
32511 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32512 {
32513 if (!wxPyCheckForApp()) SWIG_fail;
32514 PyThreadState* __tstate = wxPyBeginAllowThreads();
32515 result = (wxWindow *)wxWindow::FindFocus();
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 {
32520 resultobj = wxPyMake_wxObject(result, 0);
32521 }
32522 return resultobj;
32523 fail:
32524 return NULL;
32525 }
32526
32527
32528 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32529 PyObject *resultobj = 0;
32530 wxWindow *arg1 = (wxWindow *) 0 ;
32531 bool result;
32532 void *argp1 = 0 ;
32533 int res1 = 0 ;
32534 PyObject *swig_obj[1] ;
32535
32536 if (!args) SWIG_fail;
32537 swig_obj[0] = args;
32538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32539 if (!SWIG_IsOK(res1)) {
32540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32541 }
32542 arg1 = reinterpret_cast< wxWindow * >(argp1);
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 {
32550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32551 }
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32559 PyObject *resultobj = 0;
32560 wxWindow *arg1 = (wxWindow *) 0 ;
32561 bool result;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 PyObject *swig_obj[1] ;
32565
32566 if (!args) SWIG_fail;
32567 swig_obj[0] = args;
32568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32569 if (!SWIG_IsOK(res1)) {
32570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32571 }
32572 arg1 = reinterpret_cast< wxWindow * >(argp1);
32573 {
32574 PyThreadState* __tstate = wxPyBeginAllowThreads();
32575 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 {
32580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32581 }
32582 return resultobj;
32583 fail:
32584 return NULL;
32585 }
32586
32587
32588 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32589 PyObject *resultobj = 0;
32590 wxWindow *arg1 = (wxWindow *) 0 ;
32591 wxWindow *result = 0 ;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 PyObject *swig_obj[1] ;
32595
32596 if (!args) SWIG_fail;
32597 swig_obj[0] = args;
32598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32599 if (!SWIG_IsOK(res1)) {
32600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32601 }
32602 arg1 = reinterpret_cast< wxWindow * >(argp1);
32603 {
32604 PyThreadState* __tstate = wxPyBeginAllowThreads();
32605 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32606 wxPyEndAllowThreads(__tstate);
32607 if (PyErr_Occurred()) SWIG_fail;
32608 }
32609 {
32610 resultobj = wxPyMake_wxObject(result, 0);
32611 }
32612 return resultobj;
32613 fail:
32614 return NULL;
32615 }
32616
32617
32618 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32619 PyObject *resultobj = 0;
32620 wxWindow *arg1 = (wxWindow *) 0 ;
32621 wxWindow *arg2 = (wxWindow *) 0 ;
32622 wxWindow *result = 0 ;
32623 void *argp1 = 0 ;
32624 int res1 = 0 ;
32625 void *argp2 = 0 ;
32626 int res2 = 0 ;
32627 PyObject * obj0 = 0 ;
32628 PyObject * obj1 = 0 ;
32629 char * kwnames[] = {
32630 (char *) "self",(char *) "child", NULL
32631 };
32632
32633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32635 if (!SWIG_IsOK(res1)) {
32636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32637 }
32638 arg1 = reinterpret_cast< wxWindow * >(argp1);
32639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32640 if (!SWIG_IsOK(res2)) {
32641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32642 }
32643 arg2 = reinterpret_cast< wxWindow * >(argp2);
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 {
32651 resultobj = wxPyMake_wxObject(result, 0);
32652 }
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 wxWindow *arg2 = (wxWindow *) 0 ;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 void *argp2 = 0 ;
32666 int res2 = 0 ;
32667 PyObject * obj0 = 0 ;
32668 PyObject * obj1 = 0 ;
32669 char * kwnames[] = {
32670 (char *) "self",(char *) "win", NULL
32671 };
32672
32673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32675 if (!SWIG_IsOK(res1)) {
32676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32677 }
32678 arg1 = reinterpret_cast< wxWindow * >(argp1);
32679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32680 if (!SWIG_IsOK(res2)) {
32681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32682 }
32683 arg2 = reinterpret_cast< wxWindow * >(argp2);
32684 {
32685 PyThreadState* __tstate = wxPyBeginAllowThreads();
32686 (arg1)->SetTmpDefaultItem(arg2);
32687 wxPyEndAllowThreads(__tstate);
32688 if (PyErr_Occurred()) SWIG_fail;
32689 }
32690 resultobj = SWIG_Py_Void();
32691 return resultobj;
32692 fail:
32693 return NULL;
32694 }
32695
32696
32697 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32698 PyObject *resultobj = 0;
32699 wxWindow *arg1 = (wxWindow *) 0 ;
32700 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32701 bool result;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 int val2 ;
32705 int ecode2 = 0 ;
32706 PyObject * obj0 = 0 ;
32707 PyObject * obj1 = 0 ;
32708 char * kwnames[] = {
32709 (char *) "self",(char *) "flags", NULL
32710 };
32711
32712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32716 }
32717 arg1 = reinterpret_cast< wxWindow * >(argp1);
32718 if (obj1) {
32719 ecode2 = SWIG_AsVal_int(obj1, &val2);
32720 if (!SWIG_IsOK(ecode2)) {
32721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32722 }
32723 arg2 = static_cast< int >(val2);
32724 }
32725 {
32726 PyThreadState* __tstate = wxPyBeginAllowThreads();
32727 result = (bool)(arg1)->Navigate(arg2);
32728 wxPyEndAllowThreads(__tstate);
32729 if (PyErr_Occurred()) SWIG_fail;
32730 }
32731 {
32732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32733 }
32734 return resultobj;
32735 fail:
32736 return NULL;
32737 }
32738
32739
32740 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32741 PyObject *resultobj = 0;
32742 wxWindow *arg1 = (wxWindow *) 0 ;
32743 wxWindow *arg2 = (wxWindow *) 0 ;
32744 void *argp1 = 0 ;
32745 int res1 = 0 ;
32746 void *argp2 = 0 ;
32747 int res2 = 0 ;
32748 PyObject * obj0 = 0 ;
32749 PyObject * obj1 = 0 ;
32750 char * kwnames[] = {
32751 (char *) "self",(char *) "win", NULL
32752 };
32753
32754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32756 if (!SWIG_IsOK(res1)) {
32757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32758 }
32759 arg1 = reinterpret_cast< wxWindow * >(argp1);
32760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res2)) {
32762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32763 }
32764 arg2 = reinterpret_cast< wxWindow * >(argp2);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 (arg1)->MoveAfterInTabOrder(arg2);
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 resultobj = SWIG_Py_Void();
32772 return resultobj;
32773 fail:
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32779 PyObject *resultobj = 0;
32780 wxWindow *arg1 = (wxWindow *) 0 ;
32781 wxWindow *arg2 = (wxWindow *) 0 ;
32782 void *argp1 = 0 ;
32783 int res1 = 0 ;
32784 void *argp2 = 0 ;
32785 int res2 = 0 ;
32786 PyObject * obj0 = 0 ;
32787 PyObject * obj1 = 0 ;
32788 char * kwnames[] = {
32789 (char *) "self",(char *) "win", NULL
32790 };
32791
32792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32794 if (!SWIG_IsOK(res1)) {
32795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32796 }
32797 arg1 = reinterpret_cast< wxWindow * >(argp1);
32798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32799 if (!SWIG_IsOK(res2)) {
32800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32801 }
32802 arg2 = reinterpret_cast< wxWindow * >(argp2);
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 (arg1)->MoveBeforeInTabOrder(arg2);
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 resultobj = SWIG_Py_Void();
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 PyObject *resultobj = 0;
32818 wxWindow *arg1 = (wxWindow *) 0 ;
32819 PyObject *result = 0 ;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 PyObject *swig_obj[1] ;
32823
32824 if (!args) SWIG_fail;
32825 swig_obj[0] = args;
32826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32827 if (!SWIG_IsOK(res1)) {
32828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32829 }
32830 arg1 = reinterpret_cast< wxWindow * >(argp1);
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 result = (PyObject *)wxWindow_GetChildren(arg1);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 resultobj = result;
32838 return resultobj;
32839 fail:
32840 return NULL;
32841 }
32842
32843
32844 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32845 PyObject *resultobj = 0;
32846 wxWindow *arg1 = (wxWindow *) 0 ;
32847 wxWindow *result = 0 ;
32848 void *argp1 = 0 ;
32849 int res1 = 0 ;
32850 PyObject *swig_obj[1] ;
32851
32852 if (!args) SWIG_fail;
32853 swig_obj[0] = args;
32854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res1)) {
32856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32857 }
32858 arg1 = reinterpret_cast< wxWindow * >(argp1);
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 {
32866 resultobj = wxPyMake_wxObject(result, 0);
32867 }
32868 return resultobj;
32869 fail:
32870 return NULL;
32871 }
32872
32873
32874 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32875 PyObject *resultobj = 0;
32876 wxWindow *arg1 = (wxWindow *) 0 ;
32877 wxWindow *result = 0 ;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 PyObject *swig_obj[1] ;
32881
32882 if (!args) SWIG_fail;
32883 swig_obj[0] = args;
32884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32885 if (!SWIG_IsOK(res1)) {
32886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32887 }
32888 arg1 = reinterpret_cast< wxWindow * >(argp1);
32889 {
32890 PyThreadState* __tstate = wxPyBeginAllowThreads();
32891 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32892 wxPyEndAllowThreads(__tstate);
32893 if (PyErr_Occurred()) SWIG_fail;
32894 }
32895 {
32896 resultobj = wxPyMake_wxObject(result, 0);
32897 }
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *resultobj = 0;
32906 wxWindow *arg1 = (wxWindow *) 0 ;
32907 bool result;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32917 }
32918 arg1 = reinterpret_cast< wxWindow * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32927 }
32928 return resultobj;
32929 fail:
32930 return NULL;
32931 }
32932
32933
32934 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32935 PyObject *resultobj = 0;
32936 wxWindow *arg1 = (wxWindow *) 0 ;
32937 wxWindow *arg2 = (wxWindow *) 0 ;
32938 bool result;
32939 void *argp1 = 0 ;
32940 int res1 = 0 ;
32941 void *argp2 = 0 ;
32942 int res2 = 0 ;
32943 PyObject * obj0 = 0 ;
32944 PyObject * obj1 = 0 ;
32945 char * kwnames[] = {
32946 (char *) "self",(char *) "newParent", NULL
32947 };
32948
32949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32951 if (!SWIG_IsOK(res1)) {
32952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32953 }
32954 arg1 = reinterpret_cast< wxWindow * >(argp1);
32955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32956 if (!SWIG_IsOK(res2)) {
32957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32958 }
32959 arg2 = reinterpret_cast< wxWindow * >(argp2);
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 result = (bool)(arg1)->Reparent(arg2);
32963 wxPyEndAllowThreads(__tstate);
32964 if (PyErr_Occurred()) SWIG_fail;
32965 }
32966 {
32967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32968 }
32969 return resultobj;
32970 fail:
32971 return NULL;
32972 }
32973
32974
32975 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32976 PyObject *resultobj = 0;
32977 wxWindow *arg1 = (wxWindow *) 0 ;
32978 wxWindow *arg2 = (wxWindow *) 0 ;
32979 void *argp1 = 0 ;
32980 int res1 = 0 ;
32981 void *argp2 = 0 ;
32982 int res2 = 0 ;
32983 PyObject * obj0 = 0 ;
32984 PyObject * obj1 = 0 ;
32985 char * kwnames[] = {
32986 (char *) "self",(char *) "child", NULL
32987 };
32988
32989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32991 if (!SWIG_IsOK(res1)) {
32992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32993 }
32994 arg1 = reinterpret_cast< wxWindow * >(argp1);
32995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32996 if (!SWIG_IsOK(res2)) {
32997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32998 }
32999 arg2 = reinterpret_cast< wxWindow * >(argp2);
33000 {
33001 PyThreadState* __tstate = wxPyBeginAllowThreads();
33002 (arg1)->AddChild(arg2);
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 resultobj = SWIG_Py_Void();
33007 return resultobj;
33008 fail:
33009 return NULL;
33010 }
33011
33012
33013 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33014 PyObject *resultobj = 0;
33015 wxWindow *arg1 = (wxWindow *) 0 ;
33016 wxWindow *arg2 = (wxWindow *) 0 ;
33017 void *argp1 = 0 ;
33018 int res1 = 0 ;
33019 void *argp2 = 0 ;
33020 int res2 = 0 ;
33021 PyObject * obj0 = 0 ;
33022 PyObject * obj1 = 0 ;
33023 char * kwnames[] = {
33024 (char *) "self",(char *) "child", NULL
33025 };
33026
33027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33029 if (!SWIG_IsOK(res1)) {
33030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33031 }
33032 arg1 = reinterpret_cast< wxWindow * >(argp1);
33033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33034 if (!SWIG_IsOK(res2)) {
33035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33036 }
33037 arg2 = reinterpret_cast< wxWindow * >(argp2);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 (arg1)->RemoveChild(arg2);
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 resultobj = SWIG_Py_Void();
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33052 PyObject *resultobj = 0;
33053 wxWindow *arg1 = (wxWindow *) 0 ;
33054 long arg2 ;
33055 wxWindow *result = 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 long val2 ;
33059 int ecode2 = 0 ;
33060 PyObject * obj0 = 0 ;
33061 PyObject * obj1 = 0 ;
33062 char * kwnames[] = {
33063 (char *) "self",(char *) "winid", NULL
33064 };
33065
33066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33068 if (!SWIG_IsOK(res1)) {
33069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33070 }
33071 arg1 = reinterpret_cast< wxWindow * >(argp1);
33072 ecode2 = SWIG_AsVal_long(obj1, &val2);
33073 if (!SWIG_IsOK(ecode2)) {
33074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33075 }
33076 arg2 = static_cast< long >(val2);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (wxWindow *)(arg1)->FindWindow(arg2);
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 {
33084 resultobj = wxPyMake_wxObject(result, 0);
33085 }
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33093 PyObject *resultobj = 0;
33094 wxWindow *arg1 = (wxWindow *) 0 ;
33095 wxString *arg2 = 0 ;
33096 wxWindow *result = 0 ;
33097 void *argp1 = 0 ;
33098 int res1 = 0 ;
33099 bool temp2 = false ;
33100 PyObject * obj0 = 0 ;
33101 PyObject * obj1 = 0 ;
33102 char * kwnames[] = {
33103 (char *) "self",(char *) "name", NULL
33104 };
33105
33106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33108 if (!SWIG_IsOK(res1)) {
33109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33110 }
33111 arg1 = reinterpret_cast< wxWindow * >(argp1);
33112 {
33113 arg2 = wxString_in_helper(obj1);
33114 if (arg2 == NULL) SWIG_fail;
33115 temp2 = true;
33116 }
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33120 wxPyEndAllowThreads(__tstate);
33121 if (PyErr_Occurred()) SWIG_fail;
33122 }
33123 {
33124 resultobj = wxPyMake_wxObject(result, 0);
33125 }
33126 {
33127 if (temp2)
33128 delete arg2;
33129 }
33130 return resultobj;
33131 fail:
33132 {
33133 if (temp2)
33134 delete arg2;
33135 }
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 wxEvtHandler *result = 0 ;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 resultobj = wxPyMake_wxObject(result, 0);
33163 }
33164 return resultobj;
33165 fail:
33166 return NULL;
33167 }
33168
33169
33170 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj = 0;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33174 void *argp1 = 0 ;
33175 int res1 = 0 ;
33176 void *argp2 = 0 ;
33177 int res2 = 0 ;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char * kwnames[] = {
33181 (char *) "self",(char *) "handler", NULL
33182 };
33183
33184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33188 }
33189 arg1 = reinterpret_cast< wxWindow * >(argp1);
33190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33191 if (!SWIG_IsOK(res2)) {
33192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33193 }
33194 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33195 {
33196 PyThreadState* __tstate = wxPyBeginAllowThreads();
33197 (arg1)->SetEventHandler(arg2);
33198 wxPyEndAllowThreads(__tstate);
33199 if (PyErr_Occurred()) SWIG_fail;
33200 }
33201 resultobj = SWIG_Py_Void();
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33209 PyObject *resultobj = 0;
33210 wxWindow *arg1 = (wxWindow *) 0 ;
33211 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 void *argp2 = 0 ;
33215 int res2 = 0 ;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 char * kwnames[] = {
33219 (char *) "self",(char *) "handler", NULL
33220 };
33221
33222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33226 }
33227 arg1 = reinterpret_cast< wxWindow * >(argp1);
33228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33229 if (!SWIG_IsOK(res2)) {
33230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33231 }
33232 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33233 {
33234 PyThreadState* __tstate = wxPyBeginAllowThreads();
33235 (arg1)->PushEventHandler(arg2);
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 resultobj = SWIG_Py_Void();
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj = 0;
33248 wxWindow *arg1 = (wxWindow *) 0 ;
33249 bool arg2 = (bool) false ;
33250 wxEvtHandler *result = 0 ;
33251 void *argp1 = 0 ;
33252 int res1 = 0 ;
33253 bool val2 ;
33254 int ecode2 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char * kwnames[] = {
33258 (char *) "self",(char *) "deleteHandler", NULL
33259 };
33260
33261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33263 if (!SWIG_IsOK(res1)) {
33264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33265 }
33266 arg1 = reinterpret_cast< wxWindow * >(argp1);
33267 if (obj1) {
33268 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33269 if (!SWIG_IsOK(ecode2)) {
33270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33271 }
33272 arg2 = static_cast< bool >(val2);
33273 }
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 {
33281 resultobj = wxPyMake_wxObject(result, 0);
33282 }
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33290 PyObject *resultobj = 0;
33291 wxWindow *arg1 = (wxWindow *) 0 ;
33292 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33293 bool result;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 void *argp2 = 0 ;
33297 int res2 = 0 ;
33298 PyObject * obj0 = 0 ;
33299 PyObject * obj1 = 0 ;
33300 char * kwnames[] = {
33301 (char *) "self",(char *) "handler", NULL
33302 };
33303
33304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33306 if (!SWIG_IsOK(res1)) {
33307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33308 }
33309 arg1 = reinterpret_cast< wxWindow * >(argp1);
33310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33311 if (!SWIG_IsOK(res2)) {
33312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33313 }
33314 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (bool)(arg1)->RemoveEventHandler(arg2);
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33323 }
33324 return resultobj;
33325 fail:
33326 return NULL;
33327 }
33328
33329
33330 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33331 PyObject *resultobj = 0;
33332 wxWindow *arg1 = (wxWindow *) 0 ;
33333 wxValidator *arg2 = 0 ;
33334 void *argp1 = 0 ;
33335 int res1 = 0 ;
33336 void *argp2 = 0 ;
33337 int res2 = 0 ;
33338 PyObject * obj0 = 0 ;
33339 PyObject * obj1 = 0 ;
33340 char * kwnames[] = {
33341 (char *) "self",(char *) "validator", NULL
33342 };
33343
33344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33346 if (!SWIG_IsOK(res1)) {
33347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33348 }
33349 arg1 = reinterpret_cast< wxWindow * >(argp1);
33350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33351 if (!SWIG_IsOK(res2)) {
33352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33353 }
33354 if (!argp2) {
33355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33356 }
33357 arg2 = reinterpret_cast< wxValidator * >(argp2);
33358 {
33359 PyThreadState* __tstate = wxPyBeginAllowThreads();
33360 (arg1)->SetValidator((wxValidator const &)*arg2);
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 resultobj = SWIG_Py_Void();
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33372 PyObject *resultobj = 0;
33373 wxWindow *arg1 = (wxWindow *) 0 ;
33374 wxValidator *result = 0 ;
33375 void *argp1 = 0 ;
33376 int res1 = 0 ;
33377 PyObject *swig_obj[1] ;
33378
33379 if (!args) SWIG_fail;
33380 swig_obj[0] = args;
33381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33382 if (!SWIG_IsOK(res1)) {
33383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33384 }
33385 arg1 = reinterpret_cast< wxWindow * >(argp1);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxValidator *)(arg1)->GetValidator();
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 {
33393 resultobj = wxPyMake_wxObject(result, (bool)0);
33394 }
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33402 PyObject *resultobj = 0;
33403 wxWindow *arg1 = (wxWindow *) 0 ;
33404 bool result;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 PyObject *swig_obj[1] ;
33408
33409 if (!args) SWIG_fail;
33410 swig_obj[0] = args;
33411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33414 }
33415 arg1 = reinterpret_cast< wxWindow * >(argp1);
33416 {
33417 PyThreadState* __tstate = wxPyBeginAllowThreads();
33418 result = (bool)(arg1)->Validate();
33419 wxPyEndAllowThreads(__tstate);
33420 if (PyErr_Occurred()) SWIG_fail;
33421 }
33422 {
33423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33424 }
33425 return resultobj;
33426 fail:
33427 return NULL;
33428 }
33429
33430
33431 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33432 PyObject *resultobj = 0;
33433 wxWindow *arg1 = (wxWindow *) 0 ;
33434 bool result;
33435 void *argp1 = 0 ;
33436 int res1 = 0 ;
33437 PyObject *swig_obj[1] ;
33438
33439 if (!args) SWIG_fail;
33440 swig_obj[0] = args;
33441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33444 }
33445 arg1 = reinterpret_cast< wxWindow * >(argp1);
33446 {
33447 PyThreadState* __tstate = wxPyBeginAllowThreads();
33448 result = (bool)(arg1)->TransferDataToWindow();
33449 wxPyEndAllowThreads(__tstate);
33450 if (PyErr_Occurred()) SWIG_fail;
33451 }
33452 {
33453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33454 }
33455 return resultobj;
33456 fail:
33457 return NULL;
33458 }
33459
33460
33461 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33462 PyObject *resultobj = 0;
33463 wxWindow *arg1 = (wxWindow *) 0 ;
33464 bool result;
33465 void *argp1 = 0 ;
33466 int res1 = 0 ;
33467 PyObject *swig_obj[1] ;
33468
33469 if (!args) SWIG_fail;
33470 swig_obj[0] = args;
33471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33474 }
33475 arg1 = reinterpret_cast< wxWindow * >(argp1);
33476 {
33477 PyThreadState* __tstate = wxPyBeginAllowThreads();
33478 result = (bool)(arg1)->TransferDataFromWindow();
33479 wxPyEndAllowThreads(__tstate);
33480 if (PyErr_Occurred()) SWIG_fail;
33481 }
33482 {
33483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33484 }
33485 return resultobj;
33486 fail:
33487 return NULL;
33488 }
33489
33490
33491 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33492 PyObject *resultobj = 0;
33493 wxWindow *arg1 = (wxWindow *) 0 ;
33494 void *argp1 = 0 ;
33495 int res1 = 0 ;
33496 PyObject *swig_obj[1] ;
33497
33498 if (!args) SWIG_fail;
33499 swig_obj[0] = args;
33500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33501 if (!SWIG_IsOK(res1)) {
33502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33503 }
33504 arg1 = reinterpret_cast< wxWindow * >(argp1);
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 (arg1)->InitDialog();
33508 wxPyEndAllowThreads(__tstate);
33509 if (PyErr_Occurred()) SWIG_fail;
33510 }
33511 resultobj = SWIG_Py_Void();
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj = 0;
33520 wxWindow *arg1 = (wxWindow *) 0 ;
33521 wxAcceleratorTable *arg2 = 0 ;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 void *argp2 = 0 ;
33525 int res2 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "self",(char *) "accel", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33539 if (!SWIG_IsOK(res2)) {
33540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33541 }
33542 if (!argp2) {
33543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33544 }
33545 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 resultobj = SWIG_Py_Void();
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 wxAcceleratorTable *result = 0 ;
33563 void *argp1 = 0 ;
33564 int res1 = 0 ;
33565 PyObject *swig_obj[1] ;
33566
33567 if (!args) SWIG_fail;
33568 swig_obj[0] = args;
33569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33570 if (!SWIG_IsOK(res1)) {
33571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33572 }
33573 arg1 = reinterpret_cast< wxWindow * >(argp1);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj = 0;
33589 wxWindow *arg1 = (wxWindow *) 0 ;
33590 int arg2 ;
33591 int arg3 ;
33592 int arg4 ;
33593 bool result;
33594 void *argp1 = 0 ;
33595 int res1 = 0 ;
33596 int val2 ;
33597 int ecode2 = 0 ;
33598 int val3 ;
33599 int ecode3 = 0 ;
33600 int val4 ;
33601 int ecode4 = 0 ;
33602 PyObject * obj0 = 0 ;
33603 PyObject * obj1 = 0 ;
33604 PyObject * obj2 = 0 ;
33605 PyObject * obj3 = 0 ;
33606 char * kwnames[] = {
33607 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33608 };
33609
33610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33612 if (!SWIG_IsOK(res1)) {
33613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33614 }
33615 arg1 = reinterpret_cast< wxWindow * >(argp1);
33616 ecode2 = SWIG_AsVal_int(obj1, &val2);
33617 if (!SWIG_IsOK(ecode2)) {
33618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33619 }
33620 arg2 = static_cast< int >(val2);
33621 ecode3 = SWIG_AsVal_int(obj2, &val3);
33622 if (!SWIG_IsOK(ecode3)) {
33623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33624 }
33625 arg3 = static_cast< int >(val3);
33626 ecode4 = SWIG_AsVal_int(obj3, &val4);
33627 if (!SWIG_IsOK(ecode4)) {
33628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33629 }
33630 arg4 = static_cast< int >(val4);
33631 {
33632 PyThreadState* __tstate = wxPyBeginAllowThreads();
33633 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33634 wxPyEndAllowThreads(__tstate);
33635 if (PyErr_Occurred()) SWIG_fail;
33636 }
33637 {
33638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33639 }
33640 return resultobj;
33641 fail:
33642 return NULL;
33643 }
33644
33645
33646 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33647 PyObject *resultobj = 0;
33648 wxWindow *arg1 = (wxWindow *) 0 ;
33649 int arg2 ;
33650 bool result;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 int val2 ;
33654 int ecode2 = 0 ;
33655 PyObject * obj0 = 0 ;
33656 PyObject * obj1 = 0 ;
33657 char * kwnames[] = {
33658 (char *) "self",(char *) "hotkeyId", NULL
33659 };
33660
33661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33663 if (!SWIG_IsOK(res1)) {
33664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33665 }
33666 arg1 = reinterpret_cast< wxWindow * >(argp1);
33667 ecode2 = SWIG_AsVal_int(obj1, &val2);
33668 if (!SWIG_IsOK(ecode2)) {
33669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33670 }
33671 arg2 = static_cast< int >(val2);
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33675 wxPyEndAllowThreads(__tstate);
33676 if (PyErr_Occurred()) SWIG_fail;
33677 }
33678 {
33679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33680 }
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 wxPoint *arg2 = 0 ;
33691 wxPoint result;
33692 void *argp1 = 0 ;
33693 int res1 = 0 ;
33694 wxPoint temp2 ;
33695 PyObject * obj0 = 0 ;
33696 PyObject * obj1 = 0 ;
33697 char * kwnames[] = {
33698 (char *) "self",(char *) "pt", NULL
33699 };
33700
33701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33703 if (!SWIG_IsOK(res1)) {
33704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33705 }
33706 arg1 = reinterpret_cast< wxWindow * >(argp1);
33707 {
33708 arg2 = &temp2;
33709 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33710 }
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33714 wxPyEndAllowThreads(__tstate);
33715 if (PyErr_Occurred()) SWIG_fail;
33716 }
33717 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj = 0;
33726 wxWindow *arg1 = (wxWindow *) 0 ;
33727 wxSize *arg2 = 0 ;
33728 wxSize result;
33729 void *argp1 = 0 ;
33730 int res1 = 0 ;
33731 wxSize temp2 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "sz", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 {
33745 arg2 = &temp2;
33746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33747 }
33748 {
33749 PyThreadState* __tstate = wxPyBeginAllowThreads();
33750 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33751 wxPyEndAllowThreads(__tstate);
33752 if (PyErr_Occurred()) SWIG_fail;
33753 }
33754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33755 return resultobj;
33756 fail:
33757 return NULL;
33758 }
33759
33760
33761 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33762 PyObject *resultobj = 0;
33763 wxWindow *arg1 = (wxWindow *) 0 ;
33764 wxPoint *arg2 = 0 ;
33765 wxPoint result;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 wxPoint temp2 ;
33769 PyObject * obj0 = 0 ;
33770 PyObject * obj1 = 0 ;
33771 char * kwnames[] = {
33772 (char *) "self",(char *) "pt", NULL
33773 };
33774
33775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33777 if (!SWIG_IsOK(res1)) {
33778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33779 }
33780 arg1 = reinterpret_cast< wxWindow * >(argp1);
33781 {
33782 arg2 = &temp2;
33783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33784 }
33785 {
33786 PyThreadState* __tstate = wxPyBeginAllowThreads();
33787 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33799 PyObject *resultobj = 0;
33800 wxWindow *arg1 = (wxWindow *) 0 ;
33801 wxSize *arg2 = 0 ;
33802 wxSize result;
33803 void *argp1 = 0 ;
33804 int res1 = 0 ;
33805 wxSize temp2 ;
33806 PyObject * obj0 = 0 ;
33807 PyObject * obj1 = 0 ;
33808 char * kwnames[] = {
33809 (char *) "self",(char *) "sz", NULL
33810 };
33811
33812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33814 if (!SWIG_IsOK(res1)) {
33815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33816 }
33817 arg1 = reinterpret_cast< wxWindow * >(argp1);
33818 {
33819 arg2 = &temp2;
33820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33821 }
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33825 wxPyEndAllowThreads(__tstate);
33826 if (PyErr_Occurred()) SWIG_fail;
33827 }
33828 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33829 return resultobj;
33830 fail:
33831 return NULL;
33832 }
33833
33834
33835 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33836 PyObject *resultobj = 0;
33837 wxWindow *arg1 = (wxWindow *) 0 ;
33838 wxPoint *arg2 = 0 ;
33839 wxPoint result;
33840 void *argp1 = 0 ;
33841 int res1 = 0 ;
33842 wxPoint temp2 ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 char * kwnames[] = {
33846 (char *) "self",(char *) "pt", NULL
33847 };
33848
33849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33851 if (!SWIG_IsOK(res1)) {
33852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33853 }
33854 arg1 = reinterpret_cast< wxWindow * >(argp1);
33855 {
33856 arg2 = &temp2;
33857 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 wxSize *arg2 = 0 ;
33876 wxSize result;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 wxSize temp2 ;
33880 PyObject * obj0 = 0 ;
33881 PyObject * obj1 = 0 ;
33882 char * kwnames[] = {
33883 (char *) "self",(char *) "sz", NULL
33884 };
33885
33886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33890 }
33891 arg1 = reinterpret_cast< wxWindow * >(argp1);
33892 {
33893 arg2 = &temp2;
33894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33895 }
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 int arg2 ;
33913 int arg3 ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 int val2 ;
33917 int ecode2 = 0 ;
33918 int val3 ;
33919 int ecode3 = 0 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 PyObject * obj2 = 0 ;
33923 char * kwnames[] = {
33924 (char *) "self",(char *) "x",(char *) "y", NULL
33925 };
33926
33927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33929 if (!SWIG_IsOK(res1)) {
33930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33931 }
33932 arg1 = reinterpret_cast< wxWindow * >(argp1);
33933 ecode2 = SWIG_AsVal_int(obj1, &val2);
33934 if (!SWIG_IsOK(ecode2)) {
33935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33936 }
33937 arg2 = static_cast< int >(val2);
33938 ecode3 = SWIG_AsVal_int(obj2, &val3);
33939 if (!SWIG_IsOK(ecode3)) {
33940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33941 }
33942 arg3 = static_cast< int >(val3);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->WarpPointer(arg2,arg3);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 void *argp1 = 0 ;
33960 int res1 = 0 ;
33961 PyObject *swig_obj[1] ;
33962
33963 if (!args) SWIG_fail;
33964 swig_obj[0] = args;
33965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33966 if (!SWIG_IsOK(res1)) {
33967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33968 }
33969 arg1 = reinterpret_cast< wxWindow * >(argp1);
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->CaptureMouse();
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_Py_Void();
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33984 PyObject *resultobj = 0;
33985 wxWindow *arg1 = (wxWindow *) 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 PyObject *swig_obj[1] ;
33989
33990 if (!args) SWIG_fail;
33991 swig_obj[0] = args;
33992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->ReleaseMouse();
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_Py_Void();
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34011 PyObject *resultobj = 0;
34012 wxWindow *result = 0 ;
34013
34014 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34015 {
34016 if (!wxPyCheckForApp()) SWIG_fail;
34017 PyThreadState* __tstate = wxPyBeginAllowThreads();
34018 result = (wxWindow *)wxWindow::GetCapture();
34019 wxPyEndAllowThreads(__tstate);
34020 if (PyErr_Occurred()) SWIG_fail;
34021 }
34022 {
34023 resultobj = wxPyMake_wxObject(result, 0);
34024 }
34025 return resultobj;
34026 fail:
34027 return NULL;
34028 }
34029
34030
34031 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34032 PyObject *resultobj = 0;
34033 wxWindow *arg1 = (wxWindow *) 0 ;
34034 bool result;
34035 void *argp1 = 0 ;
34036 int res1 = 0 ;
34037 PyObject *swig_obj[1] ;
34038
34039 if (!args) SWIG_fail;
34040 swig_obj[0] = args;
34041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34042 if (!SWIG_IsOK(res1)) {
34043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34044 }
34045 arg1 = reinterpret_cast< wxWindow * >(argp1);
34046 {
34047 PyThreadState* __tstate = wxPyBeginAllowThreads();
34048 result = (bool)((wxWindow const *)arg1)->HasCapture();
34049 wxPyEndAllowThreads(__tstate);
34050 if (PyErr_Occurred()) SWIG_fail;
34051 }
34052 {
34053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34054 }
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj = 0;
34063 wxWindow *arg1 = (wxWindow *) 0 ;
34064 bool arg2 = (bool) true ;
34065 wxRect *arg3 = (wxRect *) NULL ;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 bool val2 ;
34069 int ecode2 = 0 ;
34070 void *argp3 = 0 ;
34071 int res3 = 0 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 PyObject * obj2 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 if (obj1) {
34086 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34087 if (!SWIG_IsOK(ecode2)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34089 }
34090 arg2 = static_cast< bool >(val2);
34091 }
34092 if (obj2) {
34093 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34094 if (!SWIG_IsOK(res3)) {
34095 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34096 }
34097 arg3 = reinterpret_cast< wxRect * >(argp3);
34098 }
34099 {
34100 PyThreadState* __tstate = wxPyBeginAllowThreads();
34101 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 resultobj = SWIG_Py_Void();
34106 return resultobj;
34107 fail:
34108 return NULL;
34109 }
34110
34111
34112 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34113 PyObject *resultobj = 0;
34114 wxWindow *arg1 = (wxWindow *) 0 ;
34115 wxRect *arg2 = 0 ;
34116 bool arg3 = (bool) true ;
34117 void *argp1 = 0 ;
34118 int res1 = 0 ;
34119 wxRect temp2 ;
34120 bool val3 ;
34121 int ecode3 = 0 ;
34122 PyObject * obj0 = 0 ;
34123 PyObject * obj1 = 0 ;
34124 PyObject * obj2 = 0 ;
34125 char * kwnames[] = {
34126 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34127 };
34128
34129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34131 if (!SWIG_IsOK(res1)) {
34132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34133 }
34134 arg1 = reinterpret_cast< wxWindow * >(argp1);
34135 {
34136 arg2 = &temp2;
34137 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34138 }
34139 if (obj2) {
34140 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34141 if (!SWIG_IsOK(ecode3)) {
34142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34143 }
34144 arg3 = static_cast< bool >(val3);
34145 }
34146 {
34147 PyThreadState* __tstate = wxPyBeginAllowThreads();
34148 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 resultobj = SWIG_Py_Void();
34153 return resultobj;
34154 fail:
34155 return NULL;
34156 }
34157
34158
34159 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34160 PyObject *resultobj = 0;
34161 wxWindow *arg1 = (wxWindow *) 0 ;
34162 void *argp1 = 0 ;
34163 int res1 = 0 ;
34164 PyObject *swig_obj[1] ;
34165
34166 if (!args) SWIG_fail;
34167 swig_obj[0] = args;
34168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34169 if (!SWIG_IsOK(res1)) {
34170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34171 }
34172 arg1 = reinterpret_cast< wxWindow * >(argp1);
34173 {
34174 PyThreadState* __tstate = wxPyBeginAllowThreads();
34175 (arg1)->Update();
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 resultobj = SWIG_Py_Void();
34180 return resultobj;
34181 fail:
34182 return NULL;
34183 }
34184
34185
34186 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34187 PyObject *resultobj = 0;
34188 wxWindow *arg1 = (wxWindow *) 0 ;
34189 void *argp1 = 0 ;
34190 int res1 = 0 ;
34191 PyObject *swig_obj[1] ;
34192
34193 if (!args) SWIG_fail;
34194 swig_obj[0] = args;
34195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34196 if (!SWIG_IsOK(res1)) {
34197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34198 }
34199 arg1 = reinterpret_cast< wxWindow * >(argp1);
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 (arg1)->ClearBackground();
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 resultobj = SWIG_Py_Void();
34207 return resultobj;
34208 fail:
34209 return NULL;
34210 }
34211
34212
34213 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34214 PyObject *resultobj = 0;
34215 wxWindow *arg1 = (wxWindow *) 0 ;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 PyObject *swig_obj[1] ;
34219
34220 if (!args) SWIG_fail;
34221 swig_obj[0] = args;
34222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34223 if (!SWIG_IsOK(res1)) {
34224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 (arg1)->Freeze();
34230 wxPyEndAllowThreads(__tstate);
34231 if (PyErr_Occurred()) SWIG_fail;
34232 }
34233 resultobj = SWIG_Py_Void();
34234 return resultobj;
34235 fail:
34236 return NULL;
34237 }
34238
34239
34240 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34241 PyObject *resultobj = 0;
34242 wxWindow *arg1 = (wxWindow *) 0 ;
34243 void *argp1 = 0 ;
34244 int res1 = 0 ;
34245 PyObject *swig_obj[1] ;
34246
34247 if (!args) SWIG_fail;
34248 swig_obj[0] = args;
34249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34250 if (!SWIG_IsOK(res1)) {
34251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34252 }
34253 arg1 = reinterpret_cast< wxWindow * >(argp1);
34254 {
34255 PyThreadState* __tstate = wxPyBeginAllowThreads();
34256 (arg1)->Thaw();
34257 wxPyEndAllowThreads(__tstate);
34258 if (PyErr_Occurred()) SWIG_fail;
34259 }
34260 resultobj = SWIG_Py_Void();
34261 return resultobj;
34262 fail:
34263 return NULL;
34264 }
34265
34266
34267 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34268 PyObject *resultobj = 0;
34269 wxWindow *arg1 = (wxWindow *) 0 ;
34270 wxDC *arg2 = 0 ;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 void *argp2 = 0 ;
34274 int res2 = 0 ;
34275 PyObject * obj0 = 0 ;
34276 PyObject * obj1 = 0 ;
34277 char * kwnames[] = {
34278 (char *) "self",(char *) "dc", NULL
34279 };
34280
34281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34283 if (!SWIG_IsOK(res1)) {
34284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34285 }
34286 arg1 = reinterpret_cast< wxWindow * >(argp1);
34287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34288 if (!SWIG_IsOK(res2)) {
34289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34290 }
34291 if (!argp2) {
34292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34293 }
34294 arg2 = reinterpret_cast< wxDC * >(argp2);
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 (arg1)->PrepareDC(*arg2);
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 resultobj = SWIG_Py_Void();
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34309 PyObject *resultobj = 0;
34310 wxWindow *arg1 = (wxWindow *) 0 ;
34311 wxRegion *result = 0 ;
34312 void *argp1 = 0 ;
34313 int res1 = 0 ;
34314 PyObject *swig_obj[1] ;
34315
34316 if (!args) SWIG_fail;
34317 swig_obj[0] = args;
34318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res1)) {
34320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34321 }
34322 arg1 = reinterpret_cast< wxWindow * >(argp1);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 {
34326 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34327 result = (wxRegion *) &_result_ref;
34328 }
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 wxRect result;
34343 void *argp1 = 0 ;
34344 int res1 = 0 ;
34345 PyObject *swig_obj[1] ;
34346
34347 if (!args) SWIG_fail;
34348 swig_obj[0] = args;
34349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34350 if (!SWIG_IsOK(res1)) {
34351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34352 }
34353 arg1 = reinterpret_cast< wxWindow * >(argp1);
34354 {
34355 PyThreadState* __tstate = wxPyBeginAllowThreads();
34356 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34357 wxPyEndAllowThreads(__tstate);
34358 if (PyErr_Occurred()) SWIG_fail;
34359 }
34360 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34361 return resultobj;
34362 fail:
34363 return NULL;
34364 }
34365
34366
34367 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34368 PyObject *resultobj = 0;
34369 wxWindow *arg1 = (wxWindow *) 0 ;
34370 int arg2 ;
34371 int arg3 ;
34372 int arg4 = (int) 1 ;
34373 int arg5 = (int) 1 ;
34374 bool result;
34375 void *argp1 = 0 ;
34376 int res1 = 0 ;
34377 int val2 ;
34378 int ecode2 = 0 ;
34379 int val3 ;
34380 int ecode3 = 0 ;
34381 int val4 ;
34382 int ecode4 = 0 ;
34383 int val5 ;
34384 int ecode5 = 0 ;
34385 PyObject * obj0 = 0 ;
34386 PyObject * obj1 = 0 ;
34387 PyObject * obj2 = 0 ;
34388 PyObject * obj3 = 0 ;
34389 PyObject * obj4 = 0 ;
34390 char * kwnames[] = {
34391 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34392 };
34393
34394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 ecode2 = SWIG_AsVal_int(obj1, &val2);
34401 if (!SWIG_IsOK(ecode2)) {
34402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34403 }
34404 arg2 = static_cast< int >(val2);
34405 ecode3 = SWIG_AsVal_int(obj2, &val3);
34406 if (!SWIG_IsOK(ecode3)) {
34407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34408 }
34409 arg3 = static_cast< int >(val3);
34410 if (obj3) {
34411 ecode4 = SWIG_AsVal_int(obj3, &val4);
34412 if (!SWIG_IsOK(ecode4)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34414 }
34415 arg4 = static_cast< int >(val4);
34416 }
34417 if (obj4) {
34418 ecode5 = SWIG_AsVal_int(obj4, &val5);
34419 if (!SWIG_IsOK(ecode5)) {
34420 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34421 }
34422 arg5 = static_cast< int >(val5);
34423 }
34424 {
34425 PyThreadState* __tstate = wxPyBeginAllowThreads();
34426 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34427 wxPyEndAllowThreads(__tstate);
34428 if (PyErr_Occurred()) SWIG_fail;
34429 }
34430 {
34431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34432 }
34433 return resultobj;
34434 fail:
34435 return NULL;
34436 }
34437
34438
34439 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34440 PyObject *resultobj = 0;
34441 wxWindow *arg1 = (wxWindow *) 0 ;
34442 wxPoint *arg2 = 0 ;
34443 bool result;
34444 void *argp1 = 0 ;
34445 int res1 = 0 ;
34446 wxPoint temp2 ;
34447 PyObject * obj0 = 0 ;
34448 PyObject * obj1 = 0 ;
34449 char * kwnames[] = {
34450 (char *) "self",(char *) "pt", NULL
34451 };
34452
34453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34457 }
34458 arg1 = reinterpret_cast< wxWindow * >(argp1);
34459 {
34460 arg2 = &temp2;
34461 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34462 }
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34479 PyObject *resultobj = 0;
34480 wxWindow *arg1 = (wxWindow *) 0 ;
34481 wxRect *arg2 = 0 ;
34482 bool result;
34483 void *argp1 = 0 ;
34484 int res1 = 0 ;
34485 wxRect temp2 ;
34486 PyObject * obj0 = 0 ;
34487 PyObject * obj1 = 0 ;
34488 char * kwnames[] = {
34489 (char *) "self",(char *) "rect", NULL
34490 };
34491
34492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34496 }
34497 arg1 = reinterpret_cast< wxWindow * >(argp1);
34498 {
34499 arg2 = &temp2;
34500 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 {
34509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 SwigValueWrapper<wxVisualAttributes > result;
34521 void *argp1 = 0 ;
34522 int res1 = 0 ;
34523 PyObject *swig_obj[1] ;
34524
34525 if (!args) SWIG_fail;
34526 swig_obj[0] = args;
34527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34530 }
34531 arg1 = reinterpret_cast< wxWindow * >(argp1);
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34535 wxPyEndAllowThreads(__tstate);
34536 if (PyErr_Occurred()) SWIG_fail;
34537 }
34538 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34539 return resultobj;
34540 fail:
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34546 PyObject *resultobj = 0;
34547 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34548 SwigValueWrapper<wxVisualAttributes > result;
34549 int val1 ;
34550 int ecode1 = 0 ;
34551 PyObject * obj0 = 0 ;
34552 char * kwnames[] = {
34553 (char *) "variant", NULL
34554 };
34555
34556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34557 if (obj0) {
34558 ecode1 = SWIG_AsVal_int(obj0, &val1);
34559 if (!SWIG_IsOK(ecode1)) {
34560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34561 }
34562 arg1 = static_cast< wxWindowVariant >(val1);
34563 }
34564 {
34565 if (!wxPyCheckForApp()) SWIG_fail;
34566 PyThreadState* __tstate = wxPyBeginAllowThreads();
34567 result = wxWindow::GetClassDefaultAttributes(arg1);
34568 wxPyEndAllowThreads(__tstate);
34569 if (PyErr_Occurred()) SWIG_fail;
34570 }
34571 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34579 PyObject *resultobj = 0;
34580 wxWindow *arg1 = (wxWindow *) 0 ;
34581 wxColour *arg2 = 0 ;
34582 bool result;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 wxColour temp2 ;
34586 PyObject * obj0 = 0 ;
34587 PyObject * obj1 = 0 ;
34588 char * kwnames[] = {
34589 (char *) "self",(char *) "colour", NULL
34590 };
34591
34592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34594 if (!SWIG_IsOK(res1)) {
34595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34596 }
34597 arg1 = reinterpret_cast< wxWindow * >(argp1);
34598 {
34599 arg2 = &temp2;
34600 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34601 }
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34605 wxPyEndAllowThreads(__tstate);
34606 if (PyErr_Occurred()) SWIG_fail;
34607 }
34608 {
34609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34610 }
34611 return resultobj;
34612 fail:
34613 return NULL;
34614 }
34615
34616
34617 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34618 PyObject *resultobj = 0;
34619 wxWindow *arg1 = (wxWindow *) 0 ;
34620 wxColour *arg2 = 0 ;
34621 void *argp1 = 0 ;
34622 int res1 = 0 ;
34623 wxColour temp2 ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 char * kwnames[] = {
34627 (char *) "self",(char *) "colour", NULL
34628 };
34629
34630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34632 if (!SWIG_IsOK(res1)) {
34633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34634 }
34635 arg1 = reinterpret_cast< wxWindow * >(argp1);
34636 {
34637 arg2 = &temp2;
34638 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34639 }
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_Py_Void();
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 wxColour *arg2 = 0 ;
34657 bool result;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 wxColour temp2 ;
34661 PyObject * obj0 = 0 ;
34662 PyObject * obj1 = 0 ;
34663 char * kwnames[] = {
34664 (char *) "self",(char *) "colour", NULL
34665 };
34666
34667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34671 }
34672 arg1 = reinterpret_cast< wxWindow * >(argp1);
34673 {
34674 arg2 = &temp2;
34675 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 {
34684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34685 }
34686 return resultobj;
34687 fail:
34688 return NULL;
34689 }
34690
34691
34692 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34693 PyObject *resultobj = 0;
34694 wxWindow *arg1 = (wxWindow *) 0 ;
34695 wxColour *arg2 = 0 ;
34696 void *argp1 = 0 ;
34697 int res1 = 0 ;
34698 wxColour temp2 ;
34699 PyObject * obj0 = 0 ;
34700 PyObject * obj1 = 0 ;
34701 char * kwnames[] = {
34702 (char *) "self",(char *) "colour", NULL
34703 };
34704
34705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 {
34712 arg2 = &temp2;
34713 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34714 }
34715 {
34716 PyThreadState* __tstate = wxPyBeginAllowThreads();
34717 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 resultobj = SWIG_Py_Void();
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34729 PyObject *resultobj = 0;
34730 wxWindow *arg1 = (wxWindow *) 0 ;
34731 wxColour result;
34732 void *argp1 = 0 ;
34733 int res1 = 0 ;
34734 PyObject *swig_obj[1] ;
34735
34736 if (!args) SWIG_fail;
34737 swig_obj[0] = args;
34738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34739 if (!SWIG_IsOK(res1)) {
34740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34741 }
34742 arg1 = reinterpret_cast< wxWindow * >(argp1);
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34757 PyObject *resultobj = 0;
34758 wxWindow *arg1 = (wxWindow *) 0 ;
34759 wxColour result;
34760 void *argp1 = 0 ;
34761 int res1 = 0 ;
34762 PyObject *swig_obj[1] ;
34763
34764 if (!args) SWIG_fail;
34765 swig_obj[0] = args;
34766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = ((wxWindow const *)arg1)->GetForegroundColour();
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 bool result;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 PyObject *swig_obj[1] ;
34791
34792 if (!args) SWIG_fail;
34793 swig_obj[0] = args;
34794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34795 if (!SWIG_IsOK(res1)) {
34796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34797 }
34798 arg1 = reinterpret_cast< wxWindow * >(argp1);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 {
34806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34807 }
34808 return resultobj;
34809 fail:
34810 return NULL;
34811 }
34812
34813
34814 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34815 PyObject *resultobj = 0;
34816 wxWindow *arg1 = (wxWindow *) 0 ;
34817 bool result;
34818 void *argp1 = 0 ;
34819 int res1 = 0 ;
34820 PyObject *swig_obj[1] ;
34821
34822 if (!args) SWIG_fail;
34823 swig_obj[0] = args;
34824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34825 if (!SWIG_IsOK(res1)) {
34826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34827 }
34828 arg1 = reinterpret_cast< wxWindow * >(argp1);
34829 {
34830 PyThreadState* __tstate = wxPyBeginAllowThreads();
34831 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34832 wxPyEndAllowThreads(__tstate);
34833 if (PyErr_Occurred()) SWIG_fail;
34834 }
34835 {
34836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34837 }
34838 return resultobj;
34839 fail:
34840 return NULL;
34841 }
34842
34843
34844 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj = 0;
34846 wxWindow *arg1 = (wxWindow *) 0 ;
34847 wxBackgroundStyle arg2 ;
34848 bool result;
34849 void *argp1 = 0 ;
34850 int res1 = 0 ;
34851 int val2 ;
34852 int ecode2 = 0 ;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 char * kwnames[] = {
34856 (char *) "self",(char *) "style", NULL
34857 };
34858
34859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 ecode2 = SWIG_AsVal_int(obj1, &val2);
34866 if (!SWIG_IsOK(ecode2)) {
34867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34868 }
34869 arg2 = static_cast< wxBackgroundStyle >(val2);
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34873 wxPyEndAllowThreads(__tstate);
34874 if (PyErr_Occurred()) SWIG_fail;
34875 }
34876 {
34877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34878 }
34879 return resultobj;
34880 fail:
34881 return NULL;
34882 }
34883
34884
34885 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34886 PyObject *resultobj = 0;
34887 wxWindow *arg1 = (wxWindow *) 0 ;
34888 wxBackgroundStyle result;
34889 void *argp1 = 0 ;
34890 int res1 = 0 ;
34891 PyObject *swig_obj[1] ;
34892
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34898 }
34899 arg1 = reinterpret_cast< wxWindow * >(argp1);
34900 {
34901 PyThreadState* __tstate = wxPyBeginAllowThreads();
34902 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34903 wxPyEndAllowThreads(__tstate);
34904 if (PyErr_Occurred()) SWIG_fail;
34905 }
34906 resultobj = SWIG_From_int(static_cast< int >(result));
34907 return resultobj;
34908 fail:
34909 return NULL;
34910 }
34911
34912
34913 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34914 PyObject *resultobj = 0;
34915 wxWindow *arg1 = (wxWindow *) 0 ;
34916 bool result;
34917 void *argp1 = 0 ;
34918 int res1 = 0 ;
34919 PyObject *swig_obj[1] ;
34920
34921 if (!args) SWIG_fail;
34922 swig_obj[0] = args;
34923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34926 }
34927 arg1 = reinterpret_cast< wxWindow * >(argp1);
34928 {
34929 PyThreadState* __tstate = wxPyBeginAllowThreads();
34930 result = (bool)(arg1)->HasTransparentBackground();
34931 wxPyEndAllowThreads(__tstate);
34932 if (PyErr_Occurred()) SWIG_fail;
34933 }
34934 {
34935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34936 }
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34944 PyObject *resultobj = 0;
34945 wxWindow *arg1 = (wxWindow *) 0 ;
34946 wxCursor *arg2 = 0 ;
34947 bool result;
34948 void *argp1 = 0 ;
34949 int res1 = 0 ;
34950 void *argp2 = 0 ;
34951 int res2 = 0 ;
34952 PyObject * obj0 = 0 ;
34953 PyObject * obj1 = 0 ;
34954 char * kwnames[] = {
34955 (char *) "self",(char *) "cursor", NULL
34956 };
34957
34958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34960 if (!SWIG_IsOK(res1)) {
34961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34962 }
34963 arg1 = reinterpret_cast< wxWindow * >(argp1);
34964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34965 if (!SWIG_IsOK(res2)) {
34966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34967 }
34968 if (!argp2) {
34969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34970 }
34971 arg2 = reinterpret_cast< wxCursor * >(argp2);
34972 {
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 {
34979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34980 }
34981 return resultobj;
34982 fail:
34983 return NULL;
34984 }
34985
34986
34987 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34988 PyObject *resultobj = 0;
34989 wxWindow *arg1 = (wxWindow *) 0 ;
34990 wxCursor result;
34991 void *argp1 = 0 ;
34992 int res1 = 0 ;
34993 PyObject *swig_obj[1] ;
34994
34995 if (!args) SWIG_fail;
34996 swig_obj[0] = args;
34997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34998 if (!SWIG_IsOK(res1)) {
34999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35000 }
35001 arg1 = reinterpret_cast< wxWindow * >(argp1);
35002 {
35003 PyThreadState* __tstate = wxPyBeginAllowThreads();
35004 result = (arg1)->GetCursor();
35005 wxPyEndAllowThreads(__tstate);
35006 if (PyErr_Occurred()) SWIG_fail;
35007 }
35008 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35009 return resultobj;
35010 fail:
35011 return NULL;
35012 }
35013
35014
35015 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35016 PyObject *resultobj = 0;
35017 wxWindow *arg1 = (wxWindow *) 0 ;
35018 wxFont *arg2 = 0 ;
35019 bool result;
35020 void *argp1 = 0 ;
35021 int res1 = 0 ;
35022 void *argp2 = 0 ;
35023 int res2 = 0 ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 char * kwnames[] = {
35027 (char *) "self",(char *) "font", NULL
35028 };
35029
35030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35032 if (!SWIG_IsOK(res1)) {
35033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35034 }
35035 arg1 = reinterpret_cast< wxWindow * >(argp1);
35036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35037 if (!SWIG_IsOK(res2)) {
35038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35039 }
35040 if (!argp2) {
35041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35042 }
35043 arg2 = reinterpret_cast< wxFont * >(argp2);
35044 {
35045 PyThreadState* __tstate = wxPyBeginAllowThreads();
35046 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35047 wxPyEndAllowThreads(__tstate);
35048 if (PyErr_Occurred()) SWIG_fail;
35049 }
35050 {
35051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35052 }
35053 return resultobj;
35054 fail:
35055 return NULL;
35056 }
35057
35058
35059 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35060 PyObject *resultobj = 0;
35061 wxWindow *arg1 = (wxWindow *) 0 ;
35062 wxFont *arg2 = 0 ;
35063 void *argp1 = 0 ;
35064 int res1 = 0 ;
35065 void *argp2 = 0 ;
35066 int res2 = 0 ;
35067 PyObject * obj0 = 0 ;
35068 PyObject * obj1 = 0 ;
35069 char * kwnames[] = {
35070 (char *) "self",(char *) "font", NULL
35071 };
35072
35073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35077 }
35078 arg1 = reinterpret_cast< wxWindow * >(argp1);
35079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35080 if (!SWIG_IsOK(res2)) {
35081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35082 }
35083 if (!argp2) {
35084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35085 }
35086 arg2 = reinterpret_cast< wxFont * >(argp2);
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 (arg1)->SetOwnFont((wxFont const &)*arg2);
35090 wxPyEndAllowThreads(__tstate);
35091 if (PyErr_Occurred()) SWIG_fail;
35092 }
35093 resultobj = SWIG_Py_Void();
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 wxFont result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject *swig_obj[1] ;
35107
35108 if (!args) SWIG_fail;
35109 swig_obj[0] = args;
35110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (arg1)->GetFont();
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35129 PyObject *resultobj = 0;
35130 wxWindow *arg1 = (wxWindow *) 0 ;
35131 wxCaret *arg2 = (wxCaret *) 0 ;
35132 void *argp1 = 0 ;
35133 int res1 = 0 ;
35134 int res2 = 0 ;
35135 PyObject * obj0 = 0 ;
35136 PyObject * obj1 = 0 ;
35137 char * kwnames[] = {
35138 (char *) "self",(char *) "caret", NULL
35139 };
35140
35141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35143 if (!SWIG_IsOK(res1)) {
35144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35145 }
35146 arg1 = reinterpret_cast< wxWindow * >(argp1);
35147 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35148 if (!SWIG_IsOK(res2)) {
35149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35150 }
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 (arg1)->SetCaret(arg2);
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 resultobj = SWIG_Py_Void();
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35165 PyObject *resultobj = 0;
35166 wxWindow *arg1 = (wxWindow *) 0 ;
35167 wxCaret *result = 0 ;
35168 void *argp1 = 0 ;
35169 int res1 = 0 ;
35170 PyObject *swig_obj[1] ;
35171
35172 if (!args) SWIG_fail;
35173 swig_obj[0] = args;
35174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35175 if (!SWIG_IsOK(res1)) {
35176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35177 }
35178 arg1 = reinterpret_cast< wxWindow * >(argp1);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 int result;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 PyObject *swig_obj[1] ;
35199
35200 if (!args) SWIG_fail;
35201 swig_obj[0] = args;
35202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_From_int(static_cast< int >(result));
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 int result;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 PyObject *swig_obj[1] ;
35227
35228 if (!args) SWIG_fail;
35229 swig_obj[0] = args;
35230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35231 if (!SWIG_IsOK(res1)) {
35232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35233 }
35234 arg1 = reinterpret_cast< wxWindow * >(argp1);
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35238 wxPyEndAllowThreads(__tstate);
35239 if (PyErr_Occurred()) SWIG_fail;
35240 }
35241 resultobj = SWIG_From_int(static_cast< int >(result));
35242 return resultobj;
35243 fail:
35244 return NULL;
35245 }
35246
35247
35248 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35249 PyObject *resultobj = 0;
35250 wxWindow *arg1 = (wxWindow *) 0 ;
35251 wxString *arg2 = 0 ;
35252 int *arg3 = (int *) 0 ;
35253 int *arg4 = (int *) 0 ;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 bool temp2 = false ;
35257 int temp3 ;
35258 int res3 = SWIG_TMPOBJ ;
35259 int temp4 ;
35260 int res4 = SWIG_TMPOBJ ;
35261 PyObject * obj0 = 0 ;
35262 PyObject * obj1 = 0 ;
35263 char * kwnames[] = {
35264 (char *) "self",(char *) "string", NULL
35265 };
35266
35267 arg3 = &temp3;
35268 arg4 = &temp4;
35269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35271 if (!SWIG_IsOK(res1)) {
35272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35273 }
35274 arg1 = reinterpret_cast< wxWindow * >(argp1);
35275 {
35276 arg2 = wxString_in_helper(obj1);
35277 if (arg2 == NULL) SWIG_fail;
35278 temp2 = true;
35279 }
35280 {
35281 PyThreadState* __tstate = wxPyBeginAllowThreads();
35282 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 resultobj = SWIG_Py_Void();
35287 if (SWIG_IsTmpObj(res3)) {
35288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35289 } else {
35290 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35292 }
35293 if (SWIG_IsTmpObj(res4)) {
35294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35295 } else {
35296 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35298 }
35299 {
35300 if (temp2)
35301 delete arg2;
35302 }
35303 return resultobj;
35304 fail:
35305 {
35306 if (temp2)
35307 delete arg2;
35308 }
35309 return NULL;
35310 }
35311
35312
35313 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35314 PyObject *resultobj = 0;
35315 wxWindow *arg1 = (wxWindow *) 0 ;
35316 wxString *arg2 = 0 ;
35317 int *arg3 = (int *) 0 ;
35318 int *arg4 = (int *) 0 ;
35319 int *arg5 = (int *) 0 ;
35320 int *arg6 = (int *) 0 ;
35321 wxFont *arg7 = (wxFont *) NULL ;
35322 void *argp1 = 0 ;
35323 int res1 = 0 ;
35324 bool temp2 = false ;
35325 int temp3 ;
35326 int res3 = SWIG_TMPOBJ ;
35327 int temp4 ;
35328 int res4 = SWIG_TMPOBJ ;
35329 int temp5 ;
35330 int res5 = SWIG_TMPOBJ ;
35331 int temp6 ;
35332 int res6 = SWIG_TMPOBJ ;
35333 void *argp7 = 0 ;
35334 int res7 = 0 ;
35335 PyObject * obj0 = 0 ;
35336 PyObject * obj1 = 0 ;
35337 PyObject * obj2 = 0 ;
35338 char * kwnames[] = {
35339 (char *) "self",(char *) "string",(char *) "font", NULL
35340 };
35341
35342 arg3 = &temp3;
35343 arg4 = &temp4;
35344 arg5 = &temp5;
35345 arg6 = &temp6;
35346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35348 if (!SWIG_IsOK(res1)) {
35349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35350 }
35351 arg1 = reinterpret_cast< wxWindow * >(argp1);
35352 {
35353 arg2 = wxString_in_helper(obj1);
35354 if (arg2 == NULL) SWIG_fail;
35355 temp2 = true;
35356 }
35357 if (obj2) {
35358 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35359 if (!SWIG_IsOK(res7)) {
35360 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35361 }
35362 arg7 = reinterpret_cast< wxFont * >(argp7);
35363 }
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35367 wxPyEndAllowThreads(__tstate);
35368 if (PyErr_Occurred()) SWIG_fail;
35369 }
35370 resultobj = SWIG_Py_Void();
35371 if (SWIG_IsTmpObj(res3)) {
35372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35373 } else {
35374 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35376 }
35377 if (SWIG_IsTmpObj(res4)) {
35378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35379 } else {
35380 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35382 }
35383 if (SWIG_IsTmpObj(res5)) {
35384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35385 } else {
35386 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35388 }
35389 if (SWIG_IsTmpObj(res6)) {
35390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35391 } else {
35392 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35394 }
35395 {
35396 if (temp2)
35397 delete arg2;
35398 }
35399 return resultobj;
35400 fail:
35401 {
35402 if (temp2)
35403 delete arg2;
35404 }
35405 return NULL;
35406 }
35407
35408
35409 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35410 PyObject *resultobj = 0;
35411 wxWindow *arg1 = (wxWindow *) 0 ;
35412 int *arg2 = (int *) 0 ;
35413 int *arg3 = (int *) 0 ;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 int temp2 ;
35417 int res2 = 0 ;
35418 int temp3 ;
35419 int res3 = 0 ;
35420 PyObject * obj0 = 0 ;
35421 PyObject * obj1 = 0 ;
35422 PyObject * obj2 = 0 ;
35423 char * kwnames[] = {
35424 (char *) "self",(char *) "x",(char *) "y", NULL
35425 };
35426
35427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35434 int val;
35435 int ecode = SWIG_AsVal_int(obj1, &val);
35436 if (!SWIG_IsOK(ecode)) {
35437 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35438 }
35439 temp2 = static_cast< int >(val);
35440 arg2 = &temp2;
35441 res2 = SWIG_AddTmpMask(ecode);
35442 }
35443 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35444 int val;
35445 int ecode = SWIG_AsVal_int(obj2, &val);
35446 if (!SWIG_IsOK(ecode)) {
35447 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35448 }
35449 temp3 = static_cast< int >(val);
35450 arg3 = &temp3;
35451 res3 = SWIG_AddTmpMask(ecode);
35452 }
35453 {
35454 PyThreadState* __tstate = wxPyBeginAllowThreads();
35455 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35456 wxPyEndAllowThreads(__tstate);
35457 if (PyErr_Occurred()) SWIG_fail;
35458 }
35459 resultobj = SWIG_Py_Void();
35460 if (SWIG_IsTmpObj(res2)) {
35461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35462 } else {
35463 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35465 }
35466 if (SWIG_IsTmpObj(res3)) {
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35468 } else {
35469 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35471 }
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35479 PyObject *resultobj = 0;
35480 wxWindow *arg1 = (wxWindow *) 0 ;
35481 int *arg2 = (int *) 0 ;
35482 int *arg3 = (int *) 0 ;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 int temp2 ;
35486 int res2 = 0 ;
35487 int temp3 ;
35488 int res3 = 0 ;
35489 PyObject * obj0 = 0 ;
35490 PyObject * obj1 = 0 ;
35491 PyObject * obj2 = 0 ;
35492 char * kwnames[] = {
35493 (char *) "self",(char *) "x",(char *) "y", NULL
35494 };
35495
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35503 int val;
35504 int ecode = SWIG_AsVal_int(obj1, &val);
35505 if (!SWIG_IsOK(ecode)) {
35506 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35507 }
35508 temp2 = static_cast< int >(val);
35509 arg2 = &temp2;
35510 res2 = SWIG_AddTmpMask(ecode);
35511 }
35512 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35513 int val;
35514 int ecode = SWIG_AsVal_int(obj2, &val);
35515 if (!SWIG_IsOK(ecode)) {
35516 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35517 }
35518 temp3 = static_cast< int >(val);
35519 arg3 = &temp3;
35520 res3 = SWIG_AddTmpMask(ecode);
35521 }
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 resultobj = SWIG_Py_Void();
35529 if (SWIG_IsTmpObj(res2)) {
35530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35531 } else {
35532 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35534 }
35535 if (SWIG_IsTmpObj(res3)) {
35536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35537 } else {
35538 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj = 0;
35549 wxWindow *arg1 = (wxWindow *) 0 ;
35550 wxPoint *arg2 = 0 ;
35551 wxPoint result;
35552 void *argp1 = 0 ;
35553 int res1 = 0 ;
35554 wxPoint temp2 ;
35555 PyObject * obj0 = 0 ;
35556 PyObject * obj1 = 0 ;
35557 char * kwnames[] = {
35558 (char *) "self",(char *) "pt", NULL
35559 };
35560
35561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35563 if (!SWIG_IsOK(res1)) {
35564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35565 }
35566 arg1 = reinterpret_cast< wxWindow * >(argp1);
35567 {
35568 arg2 = &temp2;
35569 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35570 }
35571 {
35572 PyThreadState* __tstate = wxPyBeginAllowThreads();
35573 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35574 wxPyEndAllowThreads(__tstate);
35575 if (PyErr_Occurred()) SWIG_fail;
35576 }
35577 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35578 return resultobj;
35579 fail:
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35585 PyObject *resultobj = 0;
35586 wxWindow *arg1 = (wxWindow *) 0 ;
35587 wxPoint *arg2 = 0 ;
35588 wxPoint result;
35589 void *argp1 = 0 ;
35590 int res1 = 0 ;
35591 wxPoint temp2 ;
35592 PyObject * obj0 = 0 ;
35593 PyObject * obj1 = 0 ;
35594 char * kwnames[] = {
35595 (char *) "self",(char *) "pt", NULL
35596 };
35597
35598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 {
35605 arg2 = &temp2;
35606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35607 }
35608 {
35609 PyThreadState* __tstate = wxPyBeginAllowThreads();
35610 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35611 wxPyEndAllowThreads(__tstate);
35612 if (PyErr_Occurred()) SWIG_fail;
35613 }
35614 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35615 return resultobj;
35616 fail:
35617 return NULL;
35618 }
35619
35620
35621 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj = 0;
35623 wxWindow *arg1 = (wxWindow *) 0 ;
35624 int arg2 ;
35625 int arg3 ;
35626 wxHitTest result;
35627 void *argp1 = 0 ;
35628 int res1 = 0 ;
35629 int val2 ;
35630 int ecode2 = 0 ;
35631 int val3 ;
35632 int ecode3 = 0 ;
35633 PyObject * obj0 = 0 ;
35634 PyObject * obj1 = 0 ;
35635 PyObject * obj2 = 0 ;
35636 char * kwnames[] = {
35637 (char *) "self",(char *) "x",(char *) "y", NULL
35638 };
35639
35640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35642 if (!SWIG_IsOK(res1)) {
35643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35644 }
35645 arg1 = reinterpret_cast< wxWindow * >(argp1);
35646 ecode2 = SWIG_AsVal_int(obj1, &val2);
35647 if (!SWIG_IsOK(ecode2)) {
35648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35649 }
35650 arg2 = static_cast< int >(val2);
35651 ecode3 = SWIG_AsVal_int(obj2, &val3);
35652 if (!SWIG_IsOK(ecode3)) {
35653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35654 }
35655 arg3 = static_cast< int >(val3);
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 resultobj = SWIG_From_int(static_cast< int >(result));
35663 return resultobj;
35664 fail:
35665 return NULL;
35666 }
35667
35668
35669 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35670 PyObject *resultobj = 0;
35671 wxWindow *arg1 = (wxWindow *) 0 ;
35672 wxPoint *arg2 = 0 ;
35673 wxHitTest result;
35674 void *argp1 = 0 ;
35675 int res1 = 0 ;
35676 wxPoint temp2 ;
35677 PyObject * obj0 = 0 ;
35678 PyObject * obj1 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "pt", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 arg2 = &temp2;
35691 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35692 }
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 resultobj = SWIG_From_int(static_cast< int >(result));
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35707 PyObject *resultobj = 0;
35708 wxWindow *arg1 = (wxWindow *) 0 ;
35709 long arg2 ;
35710 wxBorder result;
35711 void *argp1 = 0 ;
35712 int res1 = 0 ;
35713 long val2 ;
35714 int ecode2 = 0 ;
35715
35716 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35723 if (!SWIG_IsOK(ecode2)) {
35724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35725 }
35726 arg2 = static_cast< long >(val2);
35727 {
35728 PyThreadState* __tstate = wxPyBeginAllowThreads();
35729 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35730 wxPyEndAllowThreads(__tstate);
35731 if (PyErr_Occurred()) SWIG_fail;
35732 }
35733 resultobj = SWIG_From_int(static_cast< int >(result));
35734 return resultobj;
35735 fail:
35736 return NULL;
35737 }
35738
35739
35740 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35741 PyObject *resultobj = 0;
35742 wxWindow *arg1 = (wxWindow *) 0 ;
35743 wxBorder result;
35744 void *argp1 = 0 ;
35745 int res1 = 0 ;
35746
35747 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35749 if (!SWIG_IsOK(res1)) {
35750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35751 }
35752 arg1 = reinterpret_cast< wxWindow * >(argp1);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 resultobj = SWIG_From_int(static_cast< int >(result));
35760 return resultobj;
35761 fail:
35762 return NULL;
35763 }
35764
35765
35766 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35767 int argc;
35768 PyObject *argv[3];
35769
35770 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35771 --argc;
35772 if (argc == 1) {
35773 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35774 }
35775 if (argc == 2) {
35776 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35777 }
35778
35779 fail:
35780 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35781 return NULL;
35782 }
35783
35784
35785 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35786 PyObject *resultobj = 0;
35787 wxWindow *arg1 = (wxWindow *) 0 ;
35788 long arg2 = (long) wxUPDATE_UI_NONE ;
35789 void *argp1 = 0 ;
35790 int res1 = 0 ;
35791 long val2 ;
35792 int ecode2 = 0 ;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char * kwnames[] = {
35796 (char *) "self",(char *) "flags", NULL
35797 };
35798
35799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35803 }
35804 arg1 = reinterpret_cast< wxWindow * >(argp1);
35805 if (obj1) {
35806 ecode2 = SWIG_AsVal_long(obj1, &val2);
35807 if (!SWIG_IsOK(ecode2)) {
35808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35809 }
35810 arg2 = static_cast< long >(val2);
35811 }
35812 {
35813 PyThreadState* __tstate = wxPyBeginAllowThreads();
35814 (arg1)->UpdateWindowUI(arg2);
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 resultobj = SWIG_Py_Void();
35819 return resultobj;
35820 fail:
35821 return NULL;
35822 }
35823
35824
35825 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35826 PyObject *resultobj = 0;
35827 wxWindow *arg1 = (wxWindow *) 0 ;
35828 wxMenu *arg2 = (wxMenu *) 0 ;
35829 int arg3 = (int) -1 ;
35830 int arg4 = (int) -1 ;
35831 bool result;
35832 void *argp1 = 0 ;
35833 int res1 = 0 ;
35834 void *argp2 = 0 ;
35835 int res2 = 0 ;
35836 int val3 ;
35837 int ecode3 = 0 ;
35838 int val4 ;
35839 int ecode4 = 0 ;
35840 PyObject * obj0 = 0 ;
35841 PyObject * obj1 = 0 ;
35842 PyObject * obj2 = 0 ;
35843 PyObject * obj3 = 0 ;
35844 char * kwnames[] = {
35845 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35846 };
35847
35848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35850 if (!SWIG_IsOK(res1)) {
35851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35852 }
35853 arg1 = reinterpret_cast< wxWindow * >(argp1);
35854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35855 if (!SWIG_IsOK(res2)) {
35856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35857 }
35858 arg2 = reinterpret_cast< wxMenu * >(argp2);
35859 if (obj2) {
35860 ecode3 = SWIG_AsVal_int(obj2, &val3);
35861 if (!SWIG_IsOK(ecode3)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35863 }
35864 arg3 = static_cast< int >(val3);
35865 }
35866 if (obj3) {
35867 ecode4 = SWIG_AsVal_int(obj3, &val4);
35868 if (!SWIG_IsOK(ecode4)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35870 }
35871 arg4 = static_cast< int >(val4);
35872 }
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35881 }
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 wxMenu *arg2 = (wxMenu *) 0 ;
35892 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35893 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35894 bool result;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 void *argp2 = 0 ;
35898 int res2 = 0 ;
35899 wxPoint temp3 ;
35900 PyObject * obj0 = 0 ;
35901 PyObject * obj1 = 0 ;
35902 PyObject * obj2 = 0 ;
35903 char * kwnames[] = {
35904 (char *) "self",(char *) "menu",(char *) "pos", NULL
35905 };
35906
35907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35909 if (!SWIG_IsOK(res1)) {
35910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35911 }
35912 arg1 = reinterpret_cast< wxWindow * >(argp1);
35913 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35914 if (!SWIG_IsOK(res2)) {
35915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35916 }
35917 arg2 = reinterpret_cast< wxMenu * >(argp2);
35918 if (obj2) {
35919 {
35920 arg3 = &temp3;
35921 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35922 }
35923 }
35924 {
35925 PyThreadState* __tstate = wxPyBeginAllowThreads();
35926 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 {
35931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35932 }
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35940 PyObject *resultobj = 0;
35941 wxWindow *arg1 = (wxWindow *) 0 ;
35942 long result;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 PyObject *swig_obj[1] ;
35946
35947 if (!args) SWIG_fail;
35948 swig_obj[0] = args;
35949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35950 if (!SWIG_IsOK(res1)) {
35951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35952 }
35953 arg1 = reinterpret_cast< wxWindow * >(argp1);
35954 {
35955 PyThreadState* __tstate = wxPyBeginAllowThreads();
35956 result = (long)wxWindow_GetHandle(arg1);
35957 wxPyEndAllowThreads(__tstate);
35958 if (PyErr_Occurred()) SWIG_fail;
35959 }
35960 resultobj = SWIG_From_long(static_cast< long >(result));
35961 return resultobj;
35962 fail:
35963 return NULL;
35964 }
35965
35966
35967 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35968 PyObject *resultobj = 0;
35969 wxWindow *arg1 = (wxWindow *) 0 ;
35970 long arg2 ;
35971 void *argp1 = 0 ;
35972 int res1 = 0 ;
35973 long val2 ;
35974 int ecode2 = 0 ;
35975 PyObject * obj0 = 0 ;
35976 PyObject * obj1 = 0 ;
35977 char * kwnames[] = {
35978 (char *) "self",(char *) "handle", NULL
35979 };
35980
35981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35983 if (!SWIG_IsOK(res1)) {
35984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35985 }
35986 arg1 = reinterpret_cast< wxWindow * >(argp1);
35987 ecode2 = SWIG_AsVal_long(obj1, &val2);
35988 if (!SWIG_IsOK(ecode2)) {
35989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35990 }
35991 arg2 = static_cast< long >(val2);
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 wxWindow_AssociateHandle(arg1,arg2);
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_Py_Void();
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxWindow *arg1 = (wxWindow *) 0 ;
36008 void *argp1 = 0 ;
36009 int res1 = 0 ;
36010 PyObject *swig_obj[1] ;
36011
36012 if (!args) SWIG_fail;
36013 swig_obj[0] = args;
36014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36017 }
36018 arg1 = reinterpret_cast< wxWindow * >(argp1);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 (arg1)->DissociateHandle();
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_Py_Void();
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36033 PyObject *resultobj = 0;
36034 wxWindow *arg1 = (wxWindow *) 0 ;
36035 int arg2 ;
36036 bool result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 int val2 ;
36040 int ecode2 = 0 ;
36041 PyObject * obj0 = 0 ;
36042 PyObject * obj1 = 0 ;
36043 char * kwnames[] = {
36044 (char *) "self",(char *) "orient", NULL
36045 };
36046
36047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36049 if (!SWIG_IsOK(res1)) {
36050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36051 }
36052 arg1 = reinterpret_cast< wxWindow * >(argp1);
36053 ecode2 = SWIG_AsVal_int(obj1, &val2);
36054 if (!SWIG_IsOK(ecode2)) {
36055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36056 }
36057 arg2 = static_cast< int >(val2);
36058 {
36059 PyThreadState* __tstate = wxPyBeginAllowThreads();
36060 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36061 wxPyEndAllowThreads(__tstate);
36062 if (PyErr_Occurred()) SWIG_fail;
36063 }
36064 {
36065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36066 }
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36074 PyObject *resultobj = 0;
36075 wxWindow *arg1 = (wxWindow *) 0 ;
36076 int arg2 ;
36077 int arg3 ;
36078 int arg4 ;
36079 int arg5 ;
36080 bool arg6 = (bool) true ;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 int val2 ;
36084 int ecode2 = 0 ;
36085 int val3 ;
36086 int ecode3 = 0 ;
36087 int val4 ;
36088 int ecode4 = 0 ;
36089 int val5 ;
36090 int ecode5 = 0 ;
36091 bool val6 ;
36092 int ecode6 = 0 ;
36093 PyObject * obj0 = 0 ;
36094 PyObject * obj1 = 0 ;
36095 PyObject * obj2 = 0 ;
36096 PyObject * obj3 = 0 ;
36097 PyObject * obj4 = 0 ;
36098 PyObject * obj5 = 0 ;
36099 char * kwnames[] = {
36100 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36101 };
36102
36103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36105 if (!SWIG_IsOK(res1)) {
36106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36107 }
36108 arg1 = reinterpret_cast< wxWindow * >(argp1);
36109 ecode2 = SWIG_AsVal_int(obj1, &val2);
36110 if (!SWIG_IsOK(ecode2)) {
36111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36112 }
36113 arg2 = static_cast< int >(val2);
36114 ecode3 = SWIG_AsVal_int(obj2, &val3);
36115 if (!SWIG_IsOK(ecode3)) {
36116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36117 }
36118 arg3 = static_cast< int >(val3);
36119 ecode4 = SWIG_AsVal_int(obj3, &val4);
36120 if (!SWIG_IsOK(ecode4)) {
36121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36122 }
36123 arg4 = static_cast< int >(val4);
36124 ecode5 = SWIG_AsVal_int(obj4, &val5);
36125 if (!SWIG_IsOK(ecode5)) {
36126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36127 }
36128 arg5 = static_cast< int >(val5);
36129 if (obj5) {
36130 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36131 if (!SWIG_IsOK(ecode6)) {
36132 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36133 }
36134 arg6 = static_cast< bool >(val6);
36135 }
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 resultobj = SWIG_Py_Void();
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj = 0;
36151 wxWindow *arg1 = (wxWindow *) 0 ;
36152 int arg2 ;
36153 int arg3 ;
36154 bool arg4 = (bool) true ;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 int val2 ;
36158 int ecode2 = 0 ;
36159 int val3 ;
36160 int ecode3 = 0 ;
36161 bool val4 ;
36162 int ecode4 = 0 ;
36163 PyObject * obj0 = 0 ;
36164 PyObject * obj1 = 0 ;
36165 PyObject * obj2 = 0 ;
36166 PyObject * obj3 = 0 ;
36167 char * kwnames[] = {
36168 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36169 };
36170
36171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36173 if (!SWIG_IsOK(res1)) {
36174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36175 }
36176 arg1 = reinterpret_cast< wxWindow * >(argp1);
36177 ecode2 = SWIG_AsVal_int(obj1, &val2);
36178 if (!SWIG_IsOK(ecode2)) {
36179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36180 }
36181 arg2 = static_cast< int >(val2);
36182 ecode3 = SWIG_AsVal_int(obj2, &val3);
36183 if (!SWIG_IsOK(ecode3)) {
36184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36185 }
36186 arg3 = static_cast< int >(val3);
36187 if (obj3) {
36188 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36189 if (!SWIG_IsOK(ecode4)) {
36190 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36191 }
36192 arg4 = static_cast< bool >(val4);
36193 }
36194 {
36195 PyThreadState* __tstate = wxPyBeginAllowThreads();
36196 (arg1)->SetScrollPos(arg2,arg3,arg4);
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 resultobj = SWIG_Py_Void();
36201 return resultobj;
36202 fail:
36203 return NULL;
36204 }
36205
36206
36207 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36208 PyObject *resultobj = 0;
36209 wxWindow *arg1 = (wxWindow *) 0 ;
36210 int arg2 ;
36211 int result;
36212 void *argp1 = 0 ;
36213 int res1 = 0 ;
36214 int val2 ;
36215 int ecode2 = 0 ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 char * kwnames[] = {
36219 (char *) "self",(char *) "orientation", NULL
36220 };
36221
36222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36224 if (!SWIG_IsOK(res1)) {
36225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36226 }
36227 arg1 = reinterpret_cast< wxWindow * >(argp1);
36228 ecode2 = SWIG_AsVal_int(obj1, &val2);
36229 if (!SWIG_IsOK(ecode2)) {
36230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36231 }
36232 arg2 = static_cast< int >(val2);
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 resultobj = SWIG_From_int(static_cast< int >(result));
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36247 PyObject *resultobj = 0;
36248 wxWindow *arg1 = (wxWindow *) 0 ;
36249 int arg2 ;
36250 int result;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 int val2 ;
36254 int ecode2 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 char * kwnames[] = {
36258 (char *) "self",(char *) "orientation", NULL
36259 };
36260
36261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36265 }
36266 arg1 = reinterpret_cast< wxWindow * >(argp1);
36267 ecode2 = SWIG_AsVal_int(obj1, &val2);
36268 if (!SWIG_IsOK(ecode2)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36270 }
36271 arg2 = static_cast< int >(val2);
36272 {
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 resultobj = SWIG_From_int(static_cast< int >(result));
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj = 0;
36287 wxWindow *arg1 = (wxWindow *) 0 ;
36288 int arg2 ;
36289 int result;
36290 void *argp1 = 0 ;
36291 int res1 = 0 ;
36292 int val2 ;
36293 int ecode2 = 0 ;
36294 PyObject * obj0 = 0 ;
36295 PyObject * obj1 = 0 ;
36296 char * kwnames[] = {
36297 (char *) "self",(char *) "orientation", NULL
36298 };
36299
36300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36304 }
36305 arg1 = reinterpret_cast< wxWindow * >(argp1);
36306 ecode2 = SWIG_AsVal_int(obj1, &val2);
36307 if (!SWIG_IsOK(ecode2)) {
36308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36309 }
36310 arg2 = static_cast< int >(val2);
36311 {
36312 PyThreadState* __tstate = wxPyBeginAllowThreads();
36313 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36314 wxPyEndAllowThreads(__tstate);
36315 if (PyErr_Occurred()) SWIG_fail;
36316 }
36317 resultobj = SWIG_From_int(static_cast< int >(result));
36318 return resultobj;
36319 fail:
36320 return NULL;
36321 }
36322
36323
36324 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36325 PyObject *resultobj = 0;
36326 wxWindow *arg1 = (wxWindow *) 0 ;
36327 int arg2 ;
36328 int arg3 ;
36329 wxRect *arg4 = (wxRect *) NULL ;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 int val2 ;
36333 int ecode2 = 0 ;
36334 int val3 ;
36335 int ecode3 = 0 ;
36336 void *argp4 = 0 ;
36337 int res4 = 0 ;
36338 PyObject * obj0 = 0 ;
36339 PyObject * obj1 = 0 ;
36340 PyObject * obj2 = 0 ;
36341 PyObject * obj3 = 0 ;
36342 char * kwnames[] = {
36343 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36344 };
36345
36346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36348 if (!SWIG_IsOK(res1)) {
36349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36350 }
36351 arg1 = reinterpret_cast< wxWindow * >(argp1);
36352 ecode2 = SWIG_AsVal_int(obj1, &val2);
36353 if (!SWIG_IsOK(ecode2)) {
36354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36355 }
36356 arg2 = static_cast< int >(val2);
36357 ecode3 = SWIG_AsVal_int(obj2, &val3);
36358 if (!SWIG_IsOK(ecode3)) {
36359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36360 }
36361 arg3 = static_cast< int >(val3);
36362 if (obj3) {
36363 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36364 if (!SWIG_IsOK(res4)) {
36365 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36366 }
36367 arg4 = reinterpret_cast< wxRect * >(argp4);
36368 }
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 resultobj = SWIG_Py_Void();
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36383 PyObject *resultobj = 0;
36384 wxWindow *arg1 = (wxWindow *) 0 ;
36385 int arg2 ;
36386 bool result;
36387 void *argp1 = 0 ;
36388 int res1 = 0 ;
36389 int val2 ;
36390 int ecode2 = 0 ;
36391 PyObject * obj0 = 0 ;
36392 PyObject * obj1 = 0 ;
36393 char * kwnames[] = {
36394 (char *) "self",(char *) "lines", NULL
36395 };
36396
36397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36401 }
36402 arg1 = reinterpret_cast< wxWindow * >(argp1);
36403 ecode2 = SWIG_AsVal_int(obj1, &val2);
36404 if (!SWIG_IsOK(ecode2)) {
36405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36406 }
36407 arg2 = static_cast< int >(val2);
36408 {
36409 PyThreadState* __tstate = wxPyBeginAllowThreads();
36410 result = (bool)(arg1)->ScrollLines(arg2);
36411 wxPyEndAllowThreads(__tstate);
36412 if (PyErr_Occurred()) SWIG_fail;
36413 }
36414 {
36415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36416 }
36417 return resultobj;
36418 fail:
36419 return NULL;
36420 }
36421
36422
36423 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36424 PyObject *resultobj = 0;
36425 wxWindow *arg1 = (wxWindow *) 0 ;
36426 int arg2 ;
36427 bool result;
36428 void *argp1 = 0 ;
36429 int res1 = 0 ;
36430 int val2 ;
36431 int ecode2 = 0 ;
36432 PyObject * obj0 = 0 ;
36433 PyObject * obj1 = 0 ;
36434 char * kwnames[] = {
36435 (char *) "self",(char *) "pages", NULL
36436 };
36437
36438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res1)) {
36441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36442 }
36443 arg1 = reinterpret_cast< wxWindow * >(argp1);
36444 ecode2 = SWIG_AsVal_int(obj1, &val2);
36445 if (!SWIG_IsOK(ecode2)) {
36446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36447 }
36448 arg2 = static_cast< int >(val2);
36449 {
36450 PyThreadState* __tstate = wxPyBeginAllowThreads();
36451 result = (bool)(arg1)->ScrollPages(arg2);
36452 wxPyEndAllowThreads(__tstate);
36453 if (PyErr_Occurred()) SWIG_fail;
36454 }
36455 {
36456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36457 }
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 bool result;
36468 void *argp1 = 0 ;
36469 int res1 = 0 ;
36470 PyObject *swig_obj[1] ;
36471
36472 if (!args) SWIG_fail;
36473 swig_obj[0] = args;
36474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 result = (bool)(arg1)->LineUp();
36482 wxPyEndAllowThreads(__tstate);
36483 if (PyErr_Occurred()) SWIG_fail;
36484 }
36485 {
36486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36487 }
36488 return resultobj;
36489 fail:
36490 return NULL;
36491 }
36492
36493
36494 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36495 PyObject *resultobj = 0;
36496 wxWindow *arg1 = (wxWindow *) 0 ;
36497 bool result;
36498 void *argp1 = 0 ;
36499 int res1 = 0 ;
36500 PyObject *swig_obj[1] ;
36501
36502 if (!args) SWIG_fail;
36503 swig_obj[0] = args;
36504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36505 if (!SWIG_IsOK(res1)) {
36506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36507 }
36508 arg1 = reinterpret_cast< wxWindow * >(argp1);
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 result = (bool)(arg1)->LineDown();
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 {
36516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36517 }
36518 return resultobj;
36519 fail:
36520 return NULL;
36521 }
36522
36523
36524 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36525 PyObject *resultobj = 0;
36526 wxWindow *arg1 = (wxWindow *) 0 ;
36527 bool result;
36528 void *argp1 = 0 ;
36529 int res1 = 0 ;
36530 PyObject *swig_obj[1] ;
36531
36532 if (!args) SWIG_fail;
36533 swig_obj[0] = args;
36534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 {
36540 PyThreadState* __tstate = wxPyBeginAllowThreads();
36541 result = (bool)(arg1)->PageUp();
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 {
36546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36547 }
36548 return resultobj;
36549 fail:
36550 return NULL;
36551 }
36552
36553
36554 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36555 PyObject *resultobj = 0;
36556 wxWindow *arg1 = (wxWindow *) 0 ;
36557 bool result;
36558 void *argp1 = 0 ;
36559 int res1 = 0 ;
36560 PyObject *swig_obj[1] ;
36561
36562 if (!args) SWIG_fail;
36563 swig_obj[0] = args;
36564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36565 if (!SWIG_IsOK(res1)) {
36566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36567 }
36568 arg1 = reinterpret_cast< wxWindow * >(argp1);
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 result = (bool)(arg1)->PageDown();
36572 wxPyEndAllowThreads(__tstate);
36573 if (PyErr_Occurred()) SWIG_fail;
36574 }
36575 {
36576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36577 }
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36585 PyObject *resultobj = 0;
36586 wxWindow *arg1 = (wxWindow *) 0 ;
36587 wxString *arg2 = 0 ;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 bool temp2 = false ;
36591 PyObject * obj0 = 0 ;
36592 PyObject * obj1 = 0 ;
36593 char * kwnames[] = {
36594 (char *) "self",(char *) "text", NULL
36595 };
36596
36597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res1)) {
36600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36601 }
36602 arg1 = reinterpret_cast< wxWindow * >(argp1);
36603 {
36604 arg2 = wxString_in_helper(obj1);
36605 if (arg2 == NULL) SWIG_fail;
36606 temp2 = true;
36607 }
36608 {
36609 PyThreadState* __tstate = wxPyBeginAllowThreads();
36610 (arg1)->SetHelpText((wxString const &)*arg2);
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 resultobj = SWIG_Py_Void();
36615 {
36616 if (temp2)
36617 delete arg2;
36618 }
36619 return resultobj;
36620 fail:
36621 {
36622 if (temp2)
36623 delete arg2;
36624 }
36625 return NULL;
36626 }
36627
36628
36629 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 wxString *arg2 = 0 ;
36633 void *argp1 = 0 ;
36634 int res1 = 0 ;
36635 bool temp2 = false ;
36636 PyObject * obj0 = 0 ;
36637 PyObject * obj1 = 0 ;
36638 char * kwnames[] = {
36639 (char *) "self",(char *) "text", NULL
36640 };
36641
36642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36644 if (!SWIG_IsOK(res1)) {
36645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36646 }
36647 arg1 = reinterpret_cast< wxWindow * >(argp1);
36648 {
36649 arg2 = wxString_in_helper(obj1);
36650 if (arg2 == NULL) SWIG_fail;
36651 temp2 = true;
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_Py_Void();
36660 {
36661 if (temp2)
36662 delete arg2;
36663 }
36664 return resultobj;
36665 fail:
36666 {
36667 if (temp2)
36668 delete arg2;
36669 }
36670 return NULL;
36671 }
36672
36673
36674 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36675 PyObject *resultobj = 0;
36676 wxWindow *arg1 = (wxWindow *) 0 ;
36677 wxString result;
36678 void *argp1 = 0 ;
36679 int res1 = 0 ;
36680 PyObject *swig_obj[1] ;
36681
36682 if (!args) SWIG_fail;
36683 swig_obj[0] = args;
36684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36687 }
36688 arg1 = reinterpret_cast< wxWindow * >(argp1);
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 result = ((wxWindow const *)arg1)->GetHelpText();
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 {
36696 #if wxUSE_UNICODE
36697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36698 #else
36699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36700 #endif
36701 }
36702 return resultobj;
36703 fail:
36704 return NULL;
36705 }
36706
36707
36708 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36709 PyObject *resultobj = 0;
36710 wxWindow *arg1 = (wxWindow *) 0 ;
36711 wxString *arg2 = 0 ;
36712 void *argp1 = 0 ;
36713 int res1 = 0 ;
36714 bool temp2 = false ;
36715 PyObject * obj0 = 0 ;
36716 PyObject * obj1 = 0 ;
36717 char * kwnames[] = {
36718 (char *) "self",(char *) "tip", NULL
36719 };
36720
36721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 {
36728 arg2 = wxString_in_helper(obj1);
36729 if (arg2 == NULL) SWIG_fail;
36730 temp2 = true;
36731 }
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 (arg1)->SetToolTip((wxString const &)*arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 resultobj = SWIG_Py_Void();
36739 {
36740 if (temp2)
36741 delete arg2;
36742 }
36743 return resultobj;
36744 fail:
36745 {
36746 if (temp2)
36747 delete arg2;
36748 }
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 wxToolTip *arg2 = (wxToolTip *) 0 ;
36757 void *argp1 = 0 ;
36758 int res1 = 0 ;
36759 int res2 = 0 ;
36760 PyObject * obj0 = 0 ;
36761 PyObject * obj1 = 0 ;
36762 char * kwnames[] = {
36763 (char *) "self",(char *) "tip", NULL
36764 };
36765
36766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36768 if (!SWIG_IsOK(res1)) {
36769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36770 }
36771 arg1 = reinterpret_cast< wxWindow * >(argp1);
36772 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36773 if (!SWIG_IsOK(res2)) {
36774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36775 }
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 (arg1)->SetToolTip(arg2);
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 resultobj = SWIG_Py_Void();
36783 return resultobj;
36784 fail:
36785 return NULL;
36786 }
36787
36788
36789 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36790 PyObject *resultobj = 0;
36791 wxWindow *arg1 = (wxWindow *) 0 ;
36792 wxToolTip *result = 0 ;
36793 void *argp1 = 0 ;
36794 int res1 = 0 ;
36795 PyObject *swig_obj[1] ;
36796
36797 if (!args) SWIG_fail;
36798 swig_obj[0] = args;
36799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36800 if (!SWIG_IsOK(res1)) {
36801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36802 }
36803 arg1 = reinterpret_cast< wxWindow * >(argp1);
36804 {
36805 PyThreadState* __tstate = wxPyBeginAllowThreads();
36806 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36807 wxPyEndAllowThreads(__tstate);
36808 if (PyErr_Occurred()) SWIG_fail;
36809 }
36810 {
36811 resultobj = wxPyMake_wxObject(result, (bool)0);
36812 }
36813 return resultobj;
36814 fail:
36815 return NULL;
36816 }
36817
36818
36819 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36820 PyObject *resultobj = 0;
36821 wxWindow *arg1 = (wxWindow *) 0 ;
36822 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36823 void *argp1 = 0 ;
36824 int res1 = 0 ;
36825 int res2 = 0 ;
36826 PyObject * obj0 = 0 ;
36827 PyObject * obj1 = 0 ;
36828 char * kwnames[] = {
36829 (char *) "self",(char *) "dropTarget", NULL
36830 };
36831
36832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36834 if (!SWIG_IsOK(res1)) {
36835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36836 }
36837 arg1 = reinterpret_cast< wxWindow * >(argp1);
36838 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36839 if (!SWIG_IsOK(res2)) {
36840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36841 }
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->SetDropTarget(arg2);
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 resultobj = SWIG_Py_Void();
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36856 PyObject *resultobj = 0;
36857 wxWindow *arg1 = (wxWindow *) 0 ;
36858 wxPyDropTarget *result = 0 ;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 PyObject *swig_obj[1] ;
36862
36863 if (!args) SWIG_fail;
36864 swig_obj[0] = args;
36865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36866 if (!SWIG_IsOK(res1)) {
36867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36868 }
36869 arg1 = reinterpret_cast< wxWindow * >(argp1);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 bool arg2 ;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 bool val2 ;
36890 int ecode2 = 0 ;
36891 PyObject * obj0 = 0 ;
36892 PyObject * obj1 = 0 ;
36893 char * kwnames[] = {
36894 (char *) "self",(char *) "accept", NULL
36895 };
36896
36897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36899 if (!SWIG_IsOK(res1)) {
36900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36901 }
36902 arg1 = reinterpret_cast< wxWindow * >(argp1);
36903 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36904 if (!SWIG_IsOK(ecode2)) {
36905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36906 }
36907 arg2 = static_cast< bool >(val2);
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 wxWindow_DragAcceptFiles(arg1,arg2);
36911 wxPyEndAllowThreads(__tstate);
36912 if (PyErr_Occurred()) SWIG_fail;
36913 }
36914 resultobj = SWIG_Py_Void();
36915 return resultobj;
36916 fail:
36917 return NULL;
36918 }
36919
36920
36921 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36922 PyObject *resultobj = 0;
36923 wxWindow *arg1 = (wxWindow *) 0 ;
36924 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36925 void *argp1 = 0 ;
36926 int res1 = 0 ;
36927 int res2 = 0 ;
36928 PyObject * obj0 = 0 ;
36929 PyObject * obj1 = 0 ;
36930 char * kwnames[] = {
36931 (char *) "self",(char *) "constraints", NULL
36932 };
36933
36934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36938 }
36939 arg1 = reinterpret_cast< wxWindow * >(argp1);
36940 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36941 if (!SWIG_IsOK(res2)) {
36942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36943 }
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 (arg1)->SetConstraints(arg2);
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 resultobj = SWIG_Py_Void();
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 wxLayoutConstraints *result = 0 ;
36961 void *argp1 = 0 ;
36962 int res1 = 0 ;
36963 PyObject *swig_obj[1] ;
36964
36965 if (!args) SWIG_fail;
36966 swig_obj[0] = args;
36967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36968 if (!SWIG_IsOK(res1)) {
36969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36970 }
36971 arg1 = reinterpret_cast< wxWindow * >(argp1);
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj = 0;
36987 wxWindow *arg1 = (wxWindow *) 0 ;
36988 bool arg2 ;
36989 void *argp1 = 0 ;
36990 int res1 = 0 ;
36991 bool val2 ;
36992 int ecode2 = 0 ;
36993 PyObject * obj0 = 0 ;
36994 PyObject * obj1 = 0 ;
36995 char * kwnames[] = {
36996 (char *) "self",(char *) "autoLayout", NULL
36997 };
36998
36999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37001 if (!SWIG_IsOK(res1)) {
37002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37003 }
37004 arg1 = reinterpret_cast< wxWindow * >(argp1);
37005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37006 if (!SWIG_IsOK(ecode2)) {
37007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37008 }
37009 arg2 = static_cast< bool >(val2);
37010 {
37011 PyThreadState* __tstate = wxPyBeginAllowThreads();
37012 (arg1)->SetAutoLayout(arg2);
37013 wxPyEndAllowThreads(__tstate);
37014 if (PyErr_Occurred()) SWIG_fail;
37015 }
37016 resultobj = SWIG_Py_Void();
37017 return resultobj;
37018 fail:
37019 return NULL;
37020 }
37021
37022
37023 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37024 PyObject *resultobj = 0;
37025 wxWindow *arg1 = (wxWindow *) 0 ;
37026 bool result;
37027 void *argp1 = 0 ;
37028 int res1 = 0 ;
37029 PyObject *swig_obj[1] ;
37030
37031 if (!args) SWIG_fail;
37032 swig_obj[0] = args;
37033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37034 if (!SWIG_IsOK(res1)) {
37035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37036 }
37037 arg1 = reinterpret_cast< wxWindow * >(argp1);
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 {
37045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37046 }
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 bool result;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 PyObject *swig_obj[1] ;
37060
37061 if (!args) SWIG_fail;
37062 swig_obj[0] = args;
37063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37064 if (!SWIG_IsOK(res1)) {
37065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37066 }
37067 arg1 = reinterpret_cast< wxWindow * >(argp1);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = (bool)(arg1)->Layout();
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 {
37075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37076 }
37077 return resultobj;
37078 fail:
37079 return NULL;
37080 }
37081
37082
37083 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37084 PyObject *resultobj = 0;
37085 wxWindow *arg1 = (wxWindow *) 0 ;
37086 wxSizer *arg2 = (wxSizer *) 0 ;
37087 bool arg3 = (bool) true ;
37088 void *argp1 = 0 ;
37089 int res1 = 0 ;
37090 int res2 = 0 ;
37091 bool val3 ;
37092 int ecode3 = 0 ;
37093 PyObject * obj0 = 0 ;
37094 PyObject * obj1 = 0 ;
37095 PyObject * obj2 = 0 ;
37096 char * kwnames[] = {
37097 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37098 };
37099
37100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37102 if (!SWIG_IsOK(res1)) {
37103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37104 }
37105 arg1 = reinterpret_cast< wxWindow * >(argp1);
37106 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37107 if (!SWIG_IsOK(res2)) {
37108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37109 }
37110 if (obj2) {
37111 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37112 if (!SWIG_IsOK(ecode3)) {
37113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37114 }
37115 arg3 = static_cast< bool >(val3);
37116 }
37117 {
37118 PyThreadState* __tstate = wxPyBeginAllowThreads();
37119 (arg1)->SetSizer(arg2,arg3);
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 resultobj = SWIG_Py_Void();
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj = 0;
37132 wxWindow *arg1 = (wxWindow *) 0 ;
37133 wxSizer *arg2 = (wxSizer *) 0 ;
37134 bool arg3 = (bool) true ;
37135 void *argp1 = 0 ;
37136 int res1 = 0 ;
37137 int res2 = 0 ;
37138 bool val3 ;
37139 int ecode3 = 0 ;
37140 PyObject * obj0 = 0 ;
37141 PyObject * obj1 = 0 ;
37142 PyObject * obj2 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37154 if (!SWIG_IsOK(res2)) {
37155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37156 }
37157 if (obj2) {
37158 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37159 if (!SWIG_IsOK(ecode3)) {
37160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37161 }
37162 arg3 = static_cast< bool >(val3);
37163 }
37164 {
37165 PyThreadState* __tstate = wxPyBeginAllowThreads();
37166 (arg1)->SetSizerAndFit(arg2,arg3);
37167 wxPyEndAllowThreads(__tstate);
37168 if (PyErr_Occurred()) SWIG_fail;
37169 }
37170 resultobj = SWIG_Py_Void();
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37178 PyObject *resultobj = 0;
37179 wxWindow *arg1 = (wxWindow *) 0 ;
37180 wxSizer *result = 0 ;
37181 void *argp1 = 0 ;
37182 int res1 = 0 ;
37183 PyObject *swig_obj[1] ;
37184
37185 if (!args) SWIG_fail;
37186 swig_obj[0] = args;
37187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37190 }
37191 arg1 = reinterpret_cast< wxWindow * >(argp1);
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 {
37199 resultobj = wxPyMake_wxObject(result, (bool)0);
37200 }
37201 return resultobj;
37202 fail:
37203 return NULL;
37204 }
37205
37206
37207 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37208 PyObject *resultobj = 0;
37209 wxWindow *arg1 = (wxWindow *) 0 ;
37210 wxSizer *arg2 = (wxSizer *) 0 ;
37211 void *argp1 = 0 ;
37212 int res1 = 0 ;
37213 void *argp2 = 0 ;
37214 int res2 = 0 ;
37215 PyObject * obj0 = 0 ;
37216 PyObject * obj1 = 0 ;
37217 char * kwnames[] = {
37218 (char *) "self",(char *) "sizer", NULL
37219 };
37220
37221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37223 if (!SWIG_IsOK(res1)) {
37224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37225 }
37226 arg1 = reinterpret_cast< wxWindow * >(argp1);
37227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37228 if (!SWIG_IsOK(res2)) {
37229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37230 }
37231 arg2 = reinterpret_cast< wxSizer * >(argp2);
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 (arg1)->SetContainingSizer(arg2);
37235 wxPyEndAllowThreads(__tstate);
37236 if (PyErr_Occurred()) SWIG_fail;
37237 }
37238 resultobj = SWIG_Py_Void();
37239 return resultobj;
37240 fail:
37241 return NULL;
37242 }
37243
37244
37245 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37246 PyObject *resultobj = 0;
37247 wxWindow *arg1 = (wxWindow *) 0 ;
37248 wxSizer *result = 0 ;
37249 void *argp1 = 0 ;
37250 int res1 = 0 ;
37251 PyObject *swig_obj[1] ;
37252
37253 if (!args) SWIG_fail;
37254 swig_obj[0] = args;
37255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37256 if (!SWIG_IsOK(res1)) {
37257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37258 }
37259 arg1 = reinterpret_cast< wxWindow * >(argp1);
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 {
37267 resultobj = wxPyMake_wxObject(result, (bool)0);
37268 }
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37276 PyObject *resultobj = 0;
37277 wxWindow *arg1 = (wxWindow *) 0 ;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 PyObject *swig_obj[1] ;
37281
37282 if (!args) SWIG_fail;
37283 swig_obj[0] = args;
37284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 (arg1)->InheritAttributes();
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_Py_Void();
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 bool result;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 PyObject *swig_obj[1] ;
37309
37310 if (!args) SWIG_fail;
37311 swig_obj[0] = args;
37312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37313 if (!SWIG_IsOK(res1)) {
37314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37315 }
37316 arg1 = reinterpret_cast< wxWindow * >(argp1);
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 {
37324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37325 }
37326 return resultobj;
37327 fail:
37328 return NULL;
37329 }
37330
37331
37332 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37333 PyObject *obj;
37334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37335 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37336 return SWIG_Py_Void();
37337 }
37338
37339 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37340 return SWIG_Python_InitShadowInstance(args);
37341 }
37342
37343 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37344 PyObject *resultobj = 0;
37345 long arg1 ;
37346 wxWindow *arg2 = (wxWindow *) NULL ;
37347 wxWindow *result = 0 ;
37348 long val1 ;
37349 int ecode1 = 0 ;
37350 void *argp2 = 0 ;
37351 int res2 = 0 ;
37352 PyObject * obj0 = 0 ;
37353 PyObject * obj1 = 0 ;
37354 char * kwnames[] = {
37355 (char *) "id",(char *) "parent", NULL
37356 };
37357
37358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37359 ecode1 = SWIG_AsVal_long(obj0, &val1);
37360 if (!SWIG_IsOK(ecode1)) {
37361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37362 }
37363 arg1 = static_cast< long >(val1);
37364 if (obj1) {
37365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37366 if (!SWIG_IsOK(res2)) {
37367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37368 }
37369 arg2 = reinterpret_cast< wxWindow * >(argp2);
37370 }
37371 {
37372 if (!wxPyCheckForApp()) SWIG_fail;
37373 PyThreadState* __tstate = wxPyBeginAllowThreads();
37374 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37375 wxPyEndAllowThreads(__tstate);
37376 if (PyErr_Occurred()) SWIG_fail;
37377 }
37378 {
37379 resultobj = wxPyMake_wxObject(result, 0);
37380 }
37381 return resultobj;
37382 fail:
37383 return NULL;
37384 }
37385
37386
37387 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37388 PyObject *resultobj = 0;
37389 wxString *arg1 = 0 ;
37390 wxWindow *arg2 = (wxWindow *) NULL ;
37391 wxWindow *result = 0 ;
37392 bool temp1 = false ;
37393 void *argp2 = 0 ;
37394 int res2 = 0 ;
37395 PyObject * obj0 = 0 ;
37396 PyObject * obj1 = 0 ;
37397 char * kwnames[] = {
37398 (char *) "name",(char *) "parent", NULL
37399 };
37400
37401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37402 {
37403 arg1 = wxString_in_helper(obj0);
37404 if (arg1 == NULL) SWIG_fail;
37405 temp1 = true;
37406 }
37407 if (obj1) {
37408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37409 if (!SWIG_IsOK(res2)) {
37410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37411 }
37412 arg2 = reinterpret_cast< wxWindow * >(argp2);
37413 }
37414 {
37415 if (!wxPyCheckForApp()) SWIG_fail;
37416 PyThreadState* __tstate = wxPyBeginAllowThreads();
37417 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 {
37422 resultobj = wxPyMake_wxObject(result, 0);
37423 }
37424 {
37425 if (temp1)
37426 delete arg1;
37427 }
37428 return resultobj;
37429 fail:
37430 {
37431 if (temp1)
37432 delete arg1;
37433 }
37434 return NULL;
37435 }
37436
37437
37438 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37439 PyObject *resultobj = 0;
37440 wxString *arg1 = 0 ;
37441 wxWindow *arg2 = (wxWindow *) NULL ;
37442 wxWindow *result = 0 ;
37443 bool temp1 = false ;
37444 void *argp2 = 0 ;
37445 int res2 = 0 ;
37446 PyObject * obj0 = 0 ;
37447 PyObject * obj1 = 0 ;
37448 char * kwnames[] = {
37449 (char *) "label",(char *) "parent", NULL
37450 };
37451
37452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37453 {
37454 arg1 = wxString_in_helper(obj0);
37455 if (arg1 == NULL) SWIG_fail;
37456 temp1 = true;
37457 }
37458 if (obj1) {
37459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37460 if (!SWIG_IsOK(res2)) {
37461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37462 }
37463 arg2 = reinterpret_cast< wxWindow * >(argp2);
37464 }
37465 {
37466 if (!wxPyCheckForApp()) SWIG_fail;
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 {
37473 resultobj = wxPyMake_wxObject(result, 0);
37474 }
37475 {
37476 if (temp1)
37477 delete arg1;
37478 }
37479 return resultobj;
37480 fail:
37481 {
37482 if (temp1)
37483 delete arg1;
37484 }
37485 return NULL;
37486 }
37487
37488
37489 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37490 PyObject *resultobj = 0;
37491 wxWindow *arg1 = (wxWindow *) 0 ;
37492 unsigned long arg2 ;
37493 wxWindow *result = 0 ;
37494 void *argp1 = 0 ;
37495 int res1 = 0 ;
37496 unsigned long val2 ;
37497 int ecode2 = 0 ;
37498 PyObject * obj0 = 0 ;
37499 PyObject * obj1 = 0 ;
37500 char * kwnames[] = {
37501 (char *) "parent",(char *) "_hWnd", NULL
37502 };
37503
37504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37511 if (!SWIG_IsOK(ecode2)) {
37512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37513 }
37514 arg2 = static_cast< unsigned long >(val2);
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37518 wxPyEndAllowThreads(__tstate);
37519 if (PyErr_Occurred()) SWIG_fail;
37520 }
37521 {
37522 resultobj = wxPyMake_wxObject(result, 0);
37523 }
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37531 PyObject *resultobj = 0;
37532 PyObject *result = 0 ;
37533
37534 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 result = (PyObject *)GetTopLevelWindows();
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = result;
37542 return resultobj;
37543 fail:
37544 return NULL;
37545 }
37546
37547
37548 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37549 PyObject *resultobj = 0;
37550 wxValidator *result = 0 ;
37551
37552 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (wxValidator *)new wxValidator();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37567 PyObject *resultobj = 0;
37568 wxValidator *arg1 = (wxValidator *) 0 ;
37569 wxValidator *result = 0 ;
37570 void *argp1 = 0 ;
37571 int res1 = 0 ;
37572 PyObject *swig_obj[1] ;
37573
37574 if (!args) SWIG_fail;
37575 swig_obj[0] = args;
37576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37577 if (!SWIG_IsOK(res1)) {
37578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37579 }
37580 arg1 = reinterpret_cast< wxValidator * >(argp1);
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 result = (wxValidator *)(arg1)->Clone();
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 {
37588 resultobj = wxPyMake_wxObject(result, 0);
37589 }
37590 return resultobj;
37591 fail:
37592 return NULL;
37593 }
37594
37595
37596 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37597 PyObject *resultobj = 0;
37598 wxValidator *arg1 = (wxValidator *) 0 ;
37599 wxWindow *arg2 = (wxWindow *) 0 ;
37600 bool result;
37601 void *argp1 = 0 ;
37602 int res1 = 0 ;
37603 void *argp2 = 0 ;
37604 int res2 = 0 ;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 char * kwnames[] = {
37608 (char *) "self",(char *) "parent", NULL
37609 };
37610
37611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37613 if (!SWIG_IsOK(res1)) {
37614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37615 }
37616 arg1 = reinterpret_cast< wxValidator * >(argp1);
37617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37618 if (!SWIG_IsOK(res2)) {
37619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37620 }
37621 arg2 = reinterpret_cast< wxWindow * >(argp2);
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 result = (bool)(arg1)->Validate(arg2);
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 {
37629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37630 }
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxValidator *arg1 = (wxValidator *) 0 ;
37640 bool result;
37641 void *argp1 = 0 ;
37642 int res1 = 0 ;
37643 PyObject *swig_obj[1] ;
37644
37645 if (!args) SWIG_fail;
37646 swig_obj[0] = args;
37647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37648 if (!SWIG_IsOK(res1)) {
37649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37650 }
37651 arg1 = reinterpret_cast< wxValidator * >(argp1);
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 result = (bool)(arg1)->TransferToWindow();
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 {
37659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37660 }
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37668 PyObject *resultobj = 0;
37669 wxValidator *arg1 = (wxValidator *) 0 ;
37670 bool result;
37671 void *argp1 = 0 ;
37672 int res1 = 0 ;
37673 PyObject *swig_obj[1] ;
37674
37675 if (!args) SWIG_fail;
37676 swig_obj[0] = args;
37677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37678 if (!SWIG_IsOK(res1)) {
37679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37680 }
37681 arg1 = reinterpret_cast< wxValidator * >(argp1);
37682 {
37683 PyThreadState* __tstate = wxPyBeginAllowThreads();
37684 result = (bool)(arg1)->TransferFromWindow();
37685 wxPyEndAllowThreads(__tstate);
37686 if (PyErr_Occurred()) SWIG_fail;
37687 }
37688 {
37689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37690 }
37691 return resultobj;
37692 fail:
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37698 PyObject *resultobj = 0;
37699 wxValidator *arg1 = (wxValidator *) 0 ;
37700 wxWindow *result = 0 ;
37701 void *argp1 = 0 ;
37702 int res1 = 0 ;
37703 PyObject *swig_obj[1] ;
37704
37705 if (!args) SWIG_fail;
37706 swig_obj[0] = args;
37707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37710 }
37711 arg1 = reinterpret_cast< wxValidator * >(argp1);
37712 {
37713 PyThreadState* __tstate = wxPyBeginAllowThreads();
37714 result = (wxWindow *)(arg1)->GetWindow();
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 {
37719 resultobj = wxPyMake_wxObject(result, 0);
37720 }
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxValidator *arg1 = (wxValidator *) 0 ;
37730 wxWindow *arg2 = (wxWindow *) 0 ;
37731 void *argp1 = 0 ;
37732 int res1 = 0 ;
37733 void *argp2 = 0 ;
37734 int res2 = 0 ;
37735 PyObject * obj0 = 0 ;
37736 PyObject * obj1 = 0 ;
37737 char * kwnames[] = {
37738 (char *) "self",(char *) "window", NULL
37739 };
37740
37741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37743 if (!SWIG_IsOK(res1)) {
37744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37745 }
37746 arg1 = reinterpret_cast< wxValidator * >(argp1);
37747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37748 if (!SWIG_IsOK(res2)) {
37749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37750 }
37751 arg2 = reinterpret_cast< wxWindow * >(argp2);
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 (arg1)->SetWindow(arg2);
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 resultobj = SWIG_Py_Void();
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37766 PyObject *resultobj = 0;
37767 bool result;
37768
37769 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 result = (bool)wxValidator::IsSilent();
37773 wxPyEndAllowThreads(__tstate);
37774 if (PyErr_Occurred()) SWIG_fail;
37775 }
37776 {
37777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37778 }
37779 return resultobj;
37780 fail:
37781 return NULL;
37782 }
37783
37784
37785 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37786 PyObject *resultobj = 0;
37787 int arg1 = (int) true ;
37788 int val1 ;
37789 int ecode1 = 0 ;
37790 PyObject * obj0 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "doIt", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37796 if (obj0) {
37797 ecode1 = SWIG_AsVal_int(obj0, &val1);
37798 if (!SWIG_IsOK(ecode1)) {
37799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37800 }
37801 arg1 = static_cast< int >(val1);
37802 }
37803 {
37804 PyThreadState* __tstate = wxPyBeginAllowThreads();
37805 wxValidator::SetBellOnError(arg1);
37806 wxPyEndAllowThreads(__tstate);
37807 if (PyErr_Occurred()) SWIG_fail;
37808 }
37809 resultobj = SWIG_Py_Void();
37810 return resultobj;
37811 fail:
37812 return NULL;
37813 }
37814
37815
37816 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37817 PyObject *obj;
37818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37819 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37820 return SWIG_Py_Void();
37821 }
37822
37823 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37824 return SWIG_Python_InitShadowInstance(args);
37825 }
37826
37827 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37828 PyObject *resultobj = 0;
37829 wxPyValidator *result = 0 ;
37830
37831 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 result = (wxPyValidator *)new wxPyValidator();
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37846 PyObject *resultobj = 0;
37847 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37848 PyObject *arg2 = (PyObject *) 0 ;
37849 PyObject *arg3 = (PyObject *) 0 ;
37850 int arg4 = (int) true ;
37851 void *argp1 = 0 ;
37852 int res1 = 0 ;
37853 int val4 ;
37854 int ecode4 = 0 ;
37855 PyObject * obj0 = 0 ;
37856 PyObject * obj1 = 0 ;
37857 PyObject * obj2 = 0 ;
37858 PyObject * obj3 = 0 ;
37859 char * kwnames[] = {
37860 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37861 };
37862
37863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37867 }
37868 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37869 arg2 = obj1;
37870 arg3 = obj2;
37871 if (obj3) {
37872 ecode4 = SWIG_AsVal_int(obj3, &val4);
37873 if (!SWIG_IsOK(ecode4)) {
37874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37875 }
37876 arg4 = static_cast< int >(val4);
37877 }
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37881 wxPyEndAllowThreads(__tstate);
37882 if (PyErr_Occurred()) SWIG_fail;
37883 }
37884 resultobj = SWIG_Py_Void();
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *obj;
37893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37894 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37895 return SWIG_Py_Void();
37896 }
37897
37898 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37899 return SWIG_Python_InitShadowInstance(args);
37900 }
37901
37902 SWIGINTERN int DefaultValidator_set(PyObject *) {
37903 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37904 return 1;
37905 }
37906
37907
37908 SWIGINTERN PyObject *DefaultValidator_get(void) {
37909 PyObject *pyobj = 0;
37910
37911 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37912 return pyobj;
37913 }
37914
37915
37916 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37917 PyObject *resultobj = 0;
37918 wxString const &arg1_defvalue = wxPyEmptyString ;
37919 wxString *arg1 = (wxString *) &arg1_defvalue ;
37920 long arg2 = (long) 0 ;
37921 wxMenu *result = 0 ;
37922 bool temp1 = false ;
37923 long val2 ;
37924 int ecode2 = 0 ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char * kwnames[] = {
37928 (char *) "title",(char *) "style", NULL
37929 };
37930
37931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37932 if (obj0) {
37933 {
37934 arg1 = wxString_in_helper(obj0);
37935 if (arg1 == NULL) SWIG_fail;
37936 temp1 = true;
37937 }
37938 }
37939 if (obj1) {
37940 ecode2 = SWIG_AsVal_long(obj1, &val2);
37941 if (!SWIG_IsOK(ecode2)) {
37942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37943 }
37944 arg2 = static_cast< long >(val2);
37945 }
37946 {
37947 if (!wxPyCheckForApp()) SWIG_fail;
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37950 wxPyEndAllowThreads(__tstate);
37951 if (PyErr_Occurred()) SWIG_fail;
37952 }
37953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37954 {
37955 if (temp1)
37956 delete arg1;
37957 }
37958 return resultobj;
37959 fail:
37960 {
37961 if (temp1)
37962 delete arg1;
37963 }
37964 return NULL;
37965 }
37966
37967
37968 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj = 0;
37970 wxMenu *arg1 = (wxMenu *) 0 ;
37971 int arg2 ;
37972 wxString *arg3 = 0 ;
37973 wxString const &arg4_defvalue = wxPyEmptyString ;
37974 wxString *arg4 = (wxString *) &arg4_defvalue ;
37975 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
37976 wxMenuItem *result = 0 ;
37977 void *argp1 = 0 ;
37978 int res1 = 0 ;
37979 int val2 ;
37980 int ecode2 = 0 ;
37981 bool temp3 = false ;
37982 bool temp4 = false ;
37983 int val5 ;
37984 int ecode5 = 0 ;
37985 PyObject * obj0 = 0 ;
37986 PyObject * obj1 = 0 ;
37987 PyObject * obj2 = 0 ;
37988 PyObject * obj3 = 0 ;
37989 PyObject * obj4 = 0 ;
37990 char * kwnames[] = {
37991 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
37992 };
37993
37994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
37998 }
37999 arg1 = reinterpret_cast< wxMenu * >(argp1);
38000 ecode2 = SWIG_AsVal_int(obj1, &val2);
38001 if (!SWIG_IsOK(ecode2)) {
38002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38003 }
38004 arg2 = static_cast< int >(val2);
38005 {
38006 arg3 = wxString_in_helper(obj2);
38007 if (arg3 == NULL) SWIG_fail;
38008 temp3 = true;
38009 }
38010 if (obj3) {
38011 {
38012 arg4 = wxString_in_helper(obj3);
38013 if (arg4 == NULL) SWIG_fail;
38014 temp4 = true;
38015 }
38016 }
38017 if (obj4) {
38018 ecode5 = SWIG_AsVal_int(obj4, &val5);
38019 if (!SWIG_IsOK(ecode5)) {
38020 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38021 }
38022 arg5 = static_cast< wxItemKind >(val5);
38023 }
38024 {
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 {
38031 resultobj = wxPyMake_wxObject(result, (bool)0);
38032 }
38033 {
38034 if (temp3)
38035 delete arg3;
38036 }
38037 {
38038 if (temp4)
38039 delete arg4;
38040 }
38041 return resultobj;
38042 fail:
38043 {
38044 if (temp3)
38045 delete arg3;
38046 }
38047 {
38048 if (temp4)
38049 delete arg4;
38050 }
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38056 PyObject *resultobj = 0;
38057 wxMenu *arg1 = (wxMenu *) 0 ;
38058 wxMenuItem *result = 0 ;
38059 void *argp1 = 0 ;
38060 int res1 = 0 ;
38061 PyObject *swig_obj[1] ;
38062
38063 if (!args) SWIG_fail;
38064 swig_obj[0] = args;
38065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38066 if (!SWIG_IsOK(res1)) {
38067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38068 }
38069 arg1 = reinterpret_cast< wxMenu * >(argp1);
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (wxMenuItem *)(arg1)->AppendSeparator();
38073 wxPyEndAllowThreads(__tstate);
38074 if (PyErr_Occurred()) SWIG_fail;
38075 }
38076 {
38077 resultobj = wxPyMake_wxObject(result, (bool)0);
38078 }
38079 return resultobj;
38080 fail:
38081 return NULL;
38082 }
38083
38084
38085 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38086 PyObject *resultobj = 0;
38087 wxMenu *arg1 = (wxMenu *) 0 ;
38088 int arg2 ;
38089 wxString *arg3 = 0 ;
38090 wxString const &arg4_defvalue = wxPyEmptyString ;
38091 wxString *arg4 = (wxString *) &arg4_defvalue ;
38092 wxMenuItem *result = 0 ;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 int val2 ;
38096 int ecode2 = 0 ;
38097 bool temp3 = false ;
38098 bool temp4 = false ;
38099 PyObject * obj0 = 0 ;
38100 PyObject * obj1 = 0 ;
38101 PyObject * obj2 = 0 ;
38102 PyObject * obj3 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38111 }
38112 arg1 = reinterpret_cast< wxMenu * >(argp1);
38113 ecode2 = SWIG_AsVal_int(obj1, &val2);
38114 if (!SWIG_IsOK(ecode2)) {
38115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38116 }
38117 arg2 = static_cast< int >(val2);
38118 {
38119 arg3 = wxString_in_helper(obj2);
38120 if (arg3 == NULL) SWIG_fail;
38121 temp3 = true;
38122 }
38123 if (obj3) {
38124 {
38125 arg4 = wxString_in_helper(obj3);
38126 if (arg4 == NULL) SWIG_fail;
38127 temp4 = true;
38128 }
38129 }
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 {
38137 resultobj = wxPyMake_wxObject(result, (bool)0);
38138 }
38139 {
38140 if (temp3)
38141 delete arg3;
38142 }
38143 {
38144 if (temp4)
38145 delete arg4;
38146 }
38147 return resultobj;
38148 fail:
38149 {
38150 if (temp3)
38151 delete arg3;
38152 }
38153 {
38154 if (temp4)
38155 delete arg4;
38156 }
38157 return NULL;
38158 }
38159
38160
38161 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38162 PyObject *resultobj = 0;
38163 wxMenu *arg1 = (wxMenu *) 0 ;
38164 int arg2 ;
38165 wxString *arg3 = 0 ;
38166 wxString const &arg4_defvalue = wxPyEmptyString ;
38167 wxString *arg4 = (wxString *) &arg4_defvalue ;
38168 wxMenuItem *result = 0 ;
38169 void *argp1 = 0 ;
38170 int res1 = 0 ;
38171 int val2 ;
38172 int ecode2 = 0 ;
38173 bool temp3 = false ;
38174 bool temp4 = false ;
38175 PyObject * obj0 = 0 ;
38176 PyObject * obj1 = 0 ;
38177 PyObject * obj2 = 0 ;
38178 PyObject * obj3 = 0 ;
38179 char * kwnames[] = {
38180 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38181 };
38182
38183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38185 if (!SWIG_IsOK(res1)) {
38186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38187 }
38188 arg1 = reinterpret_cast< wxMenu * >(argp1);
38189 ecode2 = SWIG_AsVal_int(obj1, &val2);
38190 if (!SWIG_IsOK(ecode2)) {
38191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38192 }
38193 arg2 = static_cast< int >(val2);
38194 {
38195 arg3 = wxString_in_helper(obj2);
38196 if (arg3 == NULL) SWIG_fail;
38197 temp3 = true;
38198 }
38199 if (obj3) {
38200 {
38201 arg4 = wxString_in_helper(obj3);
38202 if (arg4 == NULL) SWIG_fail;
38203 temp4 = true;
38204 }
38205 }
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 {
38213 resultobj = wxPyMake_wxObject(result, (bool)0);
38214 }
38215 {
38216 if (temp3)
38217 delete arg3;
38218 }
38219 {
38220 if (temp4)
38221 delete arg4;
38222 }
38223 return resultobj;
38224 fail:
38225 {
38226 if (temp3)
38227 delete arg3;
38228 }
38229 {
38230 if (temp4)
38231 delete arg4;
38232 }
38233 return NULL;
38234 }
38235
38236
38237 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38238 PyObject *resultobj = 0;
38239 wxMenu *arg1 = (wxMenu *) 0 ;
38240 int arg2 ;
38241 wxString *arg3 = 0 ;
38242 wxMenu *arg4 = (wxMenu *) 0 ;
38243 wxString const &arg5_defvalue = wxPyEmptyString ;
38244 wxString *arg5 = (wxString *) &arg5_defvalue ;
38245 wxMenuItem *result = 0 ;
38246 void *argp1 = 0 ;
38247 int res1 = 0 ;
38248 int val2 ;
38249 int ecode2 = 0 ;
38250 bool temp3 = false ;
38251 void *argp4 = 0 ;
38252 int res4 = 0 ;
38253 bool temp5 = false ;
38254 PyObject * obj0 = 0 ;
38255 PyObject * obj1 = 0 ;
38256 PyObject * obj2 = 0 ;
38257 PyObject * obj3 = 0 ;
38258 PyObject * obj4 = 0 ;
38259 char * kwnames[] = {
38260 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38261 };
38262
38263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38267 }
38268 arg1 = reinterpret_cast< wxMenu * >(argp1);
38269 ecode2 = SWIG_AsVal_int(obj1, &val2);
38270 if (!SWIG_IsOK(ecode2)) {
38271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38272 }
38273 arg2 = static_cast< int >(val2);
38274 {
38275 arg3 = wxString_in_helper(obj2);
38276 if (arg3 == NULL) SWIG_fail;
38277 temp3 = true;
38278 }
38279 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38280 if (!SWIG_IsOK(res4)) {
38281 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38282 }
38283 arg4 = reinterpret_cast< wxMenu * >(argp4);
38284 if (obj4) {
38285 {
38286 arg5 = wxString_in_helper(obj4);
38287 if (arg5 == NULL) SWIG_fail;
38288 temp5 = true;
38289 }
38290 }
38291 {
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 {
38298 resultobj = wxPyMake_wxObject(result, (bool)0);
38299 }
38300 {
38301 if (temp3)
38302 delete arg3;
38303 }
38304 {
38305 if (temp5)
38306 delete arg5;
38307 }
38308 return resultobj;
38309 fail:
38310 {
38311 if (temp3)
38312 delete arg3;
38313 }
38314 {
38315 if (temp5)
38316 delete arg5;
38317 }
38318 return NULL;
38319 }
38320
38321
38322 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38323 PyObject *resultobj = 0;
38324 wxMenu *arg1 = (wxMenu *) 0 ;
38325 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38326 wxMenuItem *result = 0 ;
38327 void *argp1 = 0 ;
38328 int res1 = 0 ;
38329 int res2 = 0 ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 char * kwnames[] = {
38333 (char *) "self",(char *) "item", NULL
38334 };
38335
38336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38338 if (!SWIG_IsOK(res1)) {
38339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38340 }
38341 arg1 = reinterpret_cast< wxMenu * >(argp1);
38342 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38343 if (!SWIG_IsOK(res2)) {
38344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38345 }
38346 {
38347 PyThreadState* __tstate = wxPyBeginAllowThreads();
38348 result = (wxMenuItem *)(arg1)->Append(arg2);
38349 wxPyEndAllowThreads(__tstate);
38350 if (PyErr_Occurred()) SWIG_fail;
38351 }
38352 {
38353 resultobj = wxPyMake_wxObject(result, (bool)0);
38354 }
38355 return resultobj;
38356 fail:
38357 return NULL;
38358 }
38359
38360
38361 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38362 PyObject *resultobj = 0;
38363 wxMenu *arg1 = (wxMenu *) 0 ;
38364 size_t arg2 ;
38365 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38366 wxMenuItem *result = 0 ;
38367 void *argp1 = 0 ;
38368 int res1 = 0 ;
38369 size_t val2 ;
38370 int ecode2 = 0 ;
38371 int res3 = 0 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 char * kwnames[] = {
38376 (char *) "self",(char *) "pos",(char *) "item", NULL
38377 };
38378
38379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38381 if (!SWIG_IsOK(res1)) {
38382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38383 }
38384 arg1 = reinterpret_cast< wxMenu * >(argp1);
38385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38386 if (!SWIG_IsOK(ecode2)) {
38387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38388 }
38389 arg2 = static_cast< size_t >(val2);
38390 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38391 if (!SWIG_IsOK(res3)) {
38392 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38393 }
38394 {
38395 PyThreadState* __tstate = wxPyBeginAllowThreads();
38396 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38397 wxPyEndAllowThreads(__tstate);
38398 if (PyErr_Occurred()) SWIG_fail;
38399 }
38400 {
38401 resultobj = wxPyMake_wxObject(result, (bool)0);
38402 }
38403 return resultobj;
38404 fail:
38405 return NULL;
38406 }
38407
38408
38409 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38410 PyObject *resultobj = 0;
38411 wxMenu *arg1 = (wxMenu *) 0 ;
38412 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38413 wxMenuItem *result = 0 ;
38414 void *argp1 = 0 ;
38415 int res1 = 0 ;
38416 int res2 = 0 ;
38417 PyObject * obj0 = 0 ;
38418 PyObject * obj1 = 0 ;
38419 char * kwnames[] = {
38420 (char *) "self",(char *) "item", NULL
38421 };
38422
38423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38425 if (!SWIG_IsOK(res1)) {
38426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38427 }
38428 arg1 = reinterpret_cast< wxMenu * >(argp1);
38429 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38430 if (!SWIG_IsOK(res2)) {
38431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38432 }
38433 {
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 resultobj = wxPyMake_wxObject(result, (bool)0);
38441 }
38442 return resultobj;
38443 fail:
38444 return NULL;
38445 }
38446
38447
38448 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38449 PyObject *resultobj = 0;
38450 wxMenu *arg1 = (wxMenu *) 0 ;
38451 void *argp1 = 0 ;
38452 int res1 = 0 ;
38453 PyObject *swig_obj[1] ;
38454
38455 if (!args) SWIG_fail;
38456 swig_obj[0] = args;
38457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38458 if (!SWIG_IsOK(res1)) {
38459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38460 }
38461 arg1 = reinterpret_cast< wxMenu * >(argp1);
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 (arg1)->Break();
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 resultobj = SWIG_Py_Void();
38469 return resultobj;
38470 fail:
38471 return NULL;
38472 }
38473
38474
38475 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38476 PyObject *resultobj = 0;
38477 wxMenu *arg1 = (wxMenu *) 0 ;
38478 size_t arg2 ;
38479 int arg3 ;
38480 wxString *arg4 = 0 ;
38481 wxString const &arg5_defvalue = wxPyEmptyString ;
38482 wxString *arg5 = (wxString *) &arg5_defvalue ;
38483 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38484 wxMenuItem *result = 0 ;
38485 void *argp1 = 0 ;
38486 int res1 = 0 ;
38487 size_t val2 ;
38488 int ecode2 = 0 ;
38489 int val3 ;
38490 int ecode3 = 0 ;
38491 bool temp4 = false ;
38492 bool temp5 = false ;
38493 int val6 ;
38494 int ecode6 = 0 ;
38495 PyObject * obj0 = 0 ;
38496 PyObject * obj1 = 0 ;
38497 PyObject * obj2 = 0 ;
38498 PyObject * obj3 = 0 ;
38499 PyObject * obj4 = 0 ;
38500 PyObject * obj5 = 0 ;
38501 char * kwnames[] = {
38502 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38503 };
38504
38505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38507 if (!SWIG_IsOK(res1)) {
38508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38509 }
38510 arg1 = reinterpret_cast< wxMenu * >(argp1);
38511 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38512 if (!SWIG_IsOK(ecode2)) {
38513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38514 }
38515 arg2 = static_cast< size_t >(val2);
38516 ecode3 = SWIG_AsVal_int(obj2, &val3);
38517 if (!SWIG_IsOK(ecode3)) {
38518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38519 }
38520 arg3 = static_cast< int >(val3);
38521 {
38522 arg4 = wxString_in_helper(obj3);
38523 if (arg4 == NULL) SWIG_fail;
38524 temp4 = true;
38525 }
38526 if (obj4) {
38527 {
38528 arg5 = wxString_in_helper(obj4);
38529 if (arg5 == NULL) SWIG_fail;
38530 temp5 = true;
38531 }
38532 }
38533 if (obj5) {
38534 ecode6 = SWIG_AsVal_int(obj5, &val6);
38535 if (!SWIG_IsOK(ecode6)) {
38536 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38537 }
38538 arg6 = static_cast< wxItemKind >(val6);
38539 }
38540 {
38541 PyThreadState* __tstate = wxPyBeginAllowThreads();
38542 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38543 wxPyEndAllowThreads(__tstate);
38544 if (PyErr_Occurred()) SWIG_fail;
38545 }
38546 {
38547 resultobj = wxPyMake_wxObject(result, (bool)0);
38548 }
38549 {
38550 if (temp4)
38551 delete arg4;
38552 }
38553 {
38554 if (temp5)
38555 delete arg5;
38556 }
38557 return resultobj;
38558 fail:
38559 {
38560 if (temp4)
38561 delete arg4;
38562 }
38563 {
38564 if (temp5)
38565 delete arg5;
38566 }
38567 return NULL;
38568 }
38569
38570
38571 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38572 PyObject *resultobj = 0;
38573 wxMenu *arg1 = (wxMenu *) 0 ;
38574 size_t arg2 ;
38575 wxMenuItem *result = 0 ;
38576 void *argp1 = 0 ;
38577 int res1 = 0 ;
38578 size_t val2 ;
38579 int ecode2 = 0 ;
38580 PyObject * obj0 = 0 ;
38581 PyObject * obj1 = 0 ;
38582 char * kwnames[] = {
38583 (char *) "self",(char *) "pos", NULL
38584 };
38585
38586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38590 }
38591 arg1 = reinterpret_cast< wxMenu * >(argp1);
38592 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38593 if (!SWIG_IsOK(ecode2)) {
38594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38595 }
38596 arg2 = static_cast< size_t >(val2);
38597 {
38598 PyThreadState* __tstate = wxPyBeginAllowThreads();
38599 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38600 wxPyEndAllowThreads(__tstate);
38601 if (PyErr_Occurred()) SWIG_fail;
38602 }
38603 {
38604 resultobj = wxPyMake_wxObject(result, (bool)0);
38605 }
38606 return resultobj;
38607 fail:
38608 return NULL;
38609 }
38610
38611
38612 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj = 0;
38614 wxMenu *arg1 = (wxMenu *) 0 ;
38615 size_t arg2 ;
38616 int arg3 ;
38617 wxString *arg4 = 0 ;
38618 wxString const &arg5_defvalue = wxPyEmptyString ;
38619 wxString *arg5 = (wxString *) &arg5_defvalue ;
38620 wxMenuItem *result = 0 ;
38621 void *argp1 = 0 ;
38622 int res1 = 0 ;
38623 size_t val2 ;
38624 int ecode2 = 0 ;
38625 int val3 ;
38626 int ecode3 = 0 ;
38627 bool temp4 = false ;
38628 bool temp5 = false ;
38629 PyObject * obj0 = 0 ;
38630 PyObject * obj1 = 0 ;
38631 PyObject * obj2 = 0 ;
38632 PyObject * obj3 = 0 ;
38633 PyObject * obj4 = 0 ;
38634 char * kwnames[] = {
38635 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38636 };
38637
38638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38642 }
38643 arg1 = reinterpret_cast< wxMenu * >(argp1);
38644 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38645 if (!SWIG_IsOK(ecode2)) {
38646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38647 }
38648 arg2 = static_cast< size_t >(val2);
38649 ecode3 = SWIG_AsVal_int(obj2, &val3);
38650 if (!SWIG_IsOK(ecode3)) {
38651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38652 }
38653 arg3 = static_cast< int >(val3);
38654 {
38655 arg4 = wxString_in_helper(obj3);
38656 if (arg4 == NULL) SWIG_fail;
38657 temp4 = true;
38658 }
38659 if (obj4) {
38660 {
38661 arg5 = wxString_in_helper(obj4);
38662 if (arg5 == NULL) SWIG_fail;
38663 temp5 = true;
38664 }
38665 }
38666 {
38667 PyThreadState* __tstate = wxPyBeginAllowThreads();
38668 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38669 wxPyEndAllowThreads(__tstate);
38670 if (PyErr_Occurred()) SWIG_fail;
38671 }
38672 {
38673 resultobj = wxPyMake_wxObject(result, (bool)0);
38674 }
38675 {
38676 if (temp4)
38677 delete arg4;
38678 }
38679 {
38680 if (temp5)
38681 delete arg5;
38682 }
38683 return resultobj;
38684 fail:
38685 {
38686 if (temp4)
38687 delete arg4;
38688 }
38689 {
38690 if (temp5)
38691 delete arg5;
38692 }
38693 return NULL;
38694 }
38695
38696
38697 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38698 PyObject *resultobj = 0;
38699 wxMenu *arg1 = (wxMenu *) 0 ;
38700 size_t arg2 ;
38701 int arg3 ;
38702 wxString *arg4 = 0 ;
38703 wxString const &arg5_defvalue = wxPyEmptyString ;
38704 wxString *arg5 = (wxString *) &arg5_defvalue ;
38705 wxMenuItem *result = 0 ;
38706 void *argp1 = 0 ;
38707 int res1 = 0 ;
38708 size_t val2 ;
38709 int ecode2 = 0 ;
38710 int val3 ;
38711 int ecode3 = 0 ;
38712 bool temp4 = false ;
38713 bool temp5 = false ;
38714 PyObject * obj0 = 0 ;
38715 PyObject * obj1 = 0 ;
38716 PyObject * obj2 = 0 ;
38717 PyObject * obj3 = 0 ;
38718 PyObject * obj4 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38727 }
38728 arg1 = reinterpret_cast< wxMenu * >(argp1);
38729 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38730 if (!SWIG_IsOK(ecode2)) {
38731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38732 }
38733 arg2 = static_cast< size_t >(val2);
38734 ecode3 = SWIG_AsVal_int(obj2, &val3);
38735 if (!SWIG_IsOK(ecode3)) {
38736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38737 }
38738 arg3 = static_cast< int >(val3);
38739 {
38740 arg4 = wxString_in_helper(obj3);
38741 if (arg4 == NULL) SWIG_fail;
38742 temp4 = true;
38743 }
38744 if (obj4) {
38745 {
38746 arg5 = wxString_in_helper(obj4);
38747 if (arg5 == NULL) SWIG_fail;
38748 temp5 = true;
38749 }
38750 }
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38754 wxPyEndAllowThreads(__tstate);
38755 if (PyErr_Occurred()) SWIG_fail;
38756 }
38757 {
38758 resultobj = wxPyMake_wxObject(result, (bool)0);
38759 }
38760 {
38761 if (temp4)
38762 delete arg4;
38763 }
38764 {
38765 if (temp5)
38766 delete arg5;
38767 }
38768 return resultobj;
38769 fail:
38770 {
38771 if (temp4)
38772 delete arg4;
38773 }
38774 {
38775 if (temp5)
38776 delete arg5;
38777 }
38778 return NULL;
38779 }
38780
38781
38782 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38783 PyObject *resultobj = 0;
38784 wxMenu *arg1 = (wxMenu *) 0 ;
38785 size_t arg2 ;
38786 int arg3 ;
38787 wxString *arg4 = 0 ;
38788 wxMenu *arg5 = (wxMenu *) 0 ;
38789 wxString const &arg6_defvalue = wxPyEmptyString ;
38790 wxString *arg6 = (wxString *) &arg6_defvalue ;
38791 wxMenuItem *result = 0 ;
38792 void *argp1 = 0 ;
38793 int res1 = 0 ;
38794 size_t val2 ;
38795 int ecode2 = 0 ;
38796 int val3 ;
38797 int ecode3 = 0 ;
38798 bool temp4 = false ;
38799 void *argp5 = 0 ;
38800 int res5 = 0 ;
38801 bool temp6 = false ;
38802 PyObject * obj0 = 0 ;
38803 PyObject * obj1 = 0 ;
38804 PyObject * obj2 = 0 ;
38805 PyObject * obj3 = 0 ;
38806 PyObject * obj4 = 0 ;
38807 PyObject * obj5 = 0 ;
38808 char * kwnames[] = {
38809 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38810 };
38811
38812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38814 if (!SWIG_IsOK(res1)) {
38815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38816 }
38817 arg1 = reinterpret_cast< wxMenu * >(argp1);
38818 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38819 if (!SWIG_IsOK(ecode2)) {
38820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38821 }
38822 arg2 = static_cast< size_t >(val2);
38823 ecode3 = SWIG_AsVal_int(obj2, &val3);
38824 if (!SWIG_IsOK(ecode3)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38826 }
38827 arg3 = static_cast< int >(val3);
38828 {
38829 arg4 = wxString_in_helper(obj3);
38830 if (arg4 == NULL) SWIG_fail;
38831 temp4 = true;
38832 }
38833 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38834 if (!SWIG_IsOK(res5)) {
38835 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38836 }
38837 arg5 = reinterpret_cast< wxMenu * >(argp5);
38838 if (obj5) {
38839 {
38840 arg6 = wxString_in_helper(obj5);
38841 if (arg6 == NULL) SWIG_fail;
38842 temp6 = true;
38843 }
38844 }
38845 {
38846 PyThreadState* __tstate = wxPyBeginAllowThreads();
38847 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38848 wxPyEndAllowThreads(__tstate);
38849 if (PyErr_Occurred()) SWIG_fail;
38850 }
38851 {
38852 resultobj = wxPyMake_wxObject(result, (bool)0);
38853 }
38854 {
38855 if (temp4)
38856 delete arg4;
38857 }
38858 {
38859 if (temp6)
38860 delete arg6;
38861 }
38862 return resultobj;
38863 fail:
38864 {
38865 if (temp4)
38866 delete arg4;
38867 }
38868 {
38869 if (temp6)
38870 delete arg6;
38871 }
38872 return NULL;
38873 }
38874
38875
38876 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = 0;
38878 wxMenu *arg1 = (wxMenu *) 0 ;
38879 int arg2 ;
38880 wxString *arg3 = 0 ;
38881 wxString const &arg4_defvalue = wxPyEmptyString ;
38882 wxString *arg4 = (wxString *) &arg4_defvalue ;
38883 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38884 wxMenuItem *result = 0 ;
38885 void *argp1 = 0 ;
38886 int res1 = 0 ;
38887 int val2 ;
38888 int ecode2 = 0 ;
38889 bool temp3 = false ;
38890 bool temp4 = false ;
38891 int val5 ;
38892 int ecode5 = 0 ;
38893 PyObject * obj0 = 0 ;
38894 PyObject * obj1 = 0 ;
38895 PyObject * obj2 = 0 ;
38896 PyObject * obj3 = 0 ;
38897 PyObject * obj4 = 0 ;
38898 char * kwnames[] = {
38899 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38900 };
38901
38902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38904 if (!SWIG_IsOK(res1)) {
38905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38906 }
38907 arg1 = reinterpret_cast< wxMenu * >(argp1);
38908 ecode2 = SWIG_AsVal_int(obj1, &val2);
38909 if (!SWIG_IsOK(ecode2)) {
38910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38911 }
38912 arg2 = static_cast< int >(val2);
38913 {
38914 arg3 = wxString_in_helper(obj2);
38915 if (arg3 == NULL) SWIG_fail;
38916 temp3 = true;
38917 }
38918 if (obj3) {
38919 {
38920 arg4 = wxString_in_helper(obj3);
38921 if (arg4 == NULL) SWIG_fail;
38922 temp4 = true;
38923 }
38924 }
38925 if (obj4) {
38926 ecode5 = SWIG_AsVal_int(obj4, &val5);
38927 if (!SWIG_IsOK(ecode5)) {
38928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38929 }
38930 arg5 = static_cast< wxItemKind >(val5);
38931 }
38932 {
38933 PyThreadState* __tstate = wxPyBeginAllowThreads();
38934 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 {
38939 resultobj = wxPyMake_wxObject(result, (bool)0);
38940 }
38941 {
38942 if (temp3)
38943 delete arg3;
38944 }
38945 {
38946 if (temp4)
38947 delete arg4;
38948 }
38949 return resultobj;
38950 fail:
38951 {
38952 if (temp3)
38953 delete arg3;
38954 }
38955 {
38956 if (temp4)
38957 delete arg4;
38958 }
38959 return NULL;
38960 }
38961
38962
38963 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38964 PyObject *resultobj = 0;
38965 wxMenu *arg1 = (wxMenu *) 0 ;
38966 wxMenuItem *result = 0 ;
38967 void *argp1 = 0 ;
38968 int res1 = 0 ;
38969 PyObject *swig_obj[1] ;
38970
38971 if (!args) SWIG_fail;
38972 swig_obj[0] = args;
38973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38974 if (!SWIG_IsOK(res1)) {
38975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38976 }
38977 arg1 = reinterpret_cast< wxMenu * >(argp1);
38978 {
38979 PyThreadState* __tstate = wxPyBeginAllowThreads();
38980 result = (wxMenuItem *)(arg1)->PrependSeparator();
38981 wxPyEndAllowThreads(__tstate);
38982 if (PyErr_Occurred()) SWIG_fail;
38983 }
38984 {
38985 resultobj = wxPyMake_wxObject(result, (bool)0);
38986 }
38987 return resultobj;
38988 fail:
38989 return NULL;
38990 }
38991
38992
38993 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38994 PyObject *resultobj = 0;
38995 wxMenu *arg1 = (wxMenu *) 0 ;
38996 int arg2 ;
38997 wxString *arg3 = 0 ;
38998 wxString const &arg4_defvalue = wxPyEmptyString ;
38999 wxString *arg4 = (wxString *) &arg4_defvalue ;
39000 wxMenuItem *result = 0 ;
39001 void *argp1 = 0 ;
39002 int res1 = 0 ;
39003 int val2 ;
39004 int ecode2 = 0 ;
39005 bool temp3 = false ;
39006 bool temp4 = false ;
39007 PyObject * obj0 = 0 ;
39008 PyObject * obj1 = 0 ;
39009 PyObject * obj2 = 0 ;
39010 PyObject * obj3 = 0 ;
39011 char * kwnames[] = {
39012 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39013 };
39014
39015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39017 if (!SWIG_IsOK(res1)) {
39018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39019 }
39020 arg1 = reinterpret_cast< wxMenu * >(argp1);
39021 ecode2 = SWIG_AsVal_int(obj1, &val2);
39022 if (!SWIG_IsOK(ecode2)) {
39023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39024 }
39025 arg2 = static_cast< int >(val2);
39026 {
39027 arg3 = wxString_in_helper(obj2);
39028 if (arg3 == NULL) SWIG_fail;
39029 temp3 = true;
39030 }
39031 if (obj3) {
39032 {
39033 arg4 = wxString_in_helper(obj3);
39034 if (arg4 == NULL) SWIG_fail;
39035 temp4 = true;
39036 }
39037 }
39038 {
39039 PyThreadState* __tstate = wxPyBeginAllowThreads();
39040 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39041 wxPyEndAllowThreads(__tstate);
39042 if (PyErr_Occurred()) SWIG_fail;
39043 }
39044 {
39045 resultobj = wxPyMake_wxObject(result, (bool)0);
39046 }
39047 {
39048 if (temp3)
39049 delete arg3;
39050 }
39051 {
39052 if (temp4)
39053 delete arg4;
39054 }
39055 return resultobj;
39056 fail:
39057 {
39058 if (temp3)
39059 delete arg3;
39060 }
39061 {
39062 if (temp4)
39063 delete arg4;
39064 }
39065 return NULL;
39066 }
39067
39068
39069 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39070 PyObject *resultobj = 0;
39071 wxMenu *arg1 = (wxMenu *) 0 ;
39072 int arg2 ;
39073 wxString *arg3 = 0 ;
39074 wxString const &arg4_defvalue = wxPyEmptyString ;
39075 wxString *arg4 = (wxString *) &arg4_defvalue ;
39076 wxMenuItem *result = 0 ;
39077 void *argp1 = 0 ;
39078 int res1 = 0 ;
39079 int val2 ;
39080 int ecode2 = 0 ;
39081 bool temp3 = false ;
39082 bool temp4 = false ;
39083 PyObject * obj0 = 0 ;
39084 PyObject * obj1 = 0 ;
39085 PyObject * obj2 = 0 ;
39086 PyObject * obj3 = 0 ;
39087 char * kwnames[] = {
39088 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39089 };
39090
39091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39093 if (!SWIG_IsOK(res1)) {
39094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39095 }
39096 arg1 = reinterpret_cast< wxMenu * >(argp1);
39097 ecode2 = SWIG_AsVal_int(obj1, &val2);
39098 if (!SWIG_IsOK(ecode2)) {
39099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39100 }
39101 arg2 = static_cast< int >(val2);
39102 {
39103 arg3 = wxString_in_helper(obj2);
39104 if (arg3 == NULL) SWIG_fail;
39105 temp3 = true;
39106 }
39107 if (obj3) {
39108 {
39109 arg4 = wxString_in_helper(obj3);
39110 if (arg4 == NULL) SWIG_fail;
39111 temp4 = true;
39112 }
39113 }
39114 {
39115 PyThreadState* __tstate = wxPyBeginAllowThreads();
39116 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39117 wxPyEndAllowThreads(__tstate);
39118 if (PyErr_Occurred()) SWIG_fail;
39119 }
39120 {
39121 resultobj = wxPyMake_wxObject(result, (bool)0);
39122 }
39123 {
39124 if (temp3)
39125 delete arg3;
39126 }
39127 {
39128 if (temp4)
39129 delete arg4;
39130 }
39131 return resultobj;
39132 fail:
39133 {
39134 if (temp3)
39135 delete arg3;
39136 }
39137 {
39138 if (temp4)
39139 delete arg4;
39140 }
39141 return NULL;
39142 }
39143
39144
39145 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj = 0;
39147 wxMenu *arg1 = (wxMenu *) 0 ;
39148 int arg2 ;
39149 wxString *arg3 = 0 ;
39150 wxMenu *arg4 = (wxMenu *) 0 ;
39151 wxString const &arg5_defvalue = wxPyEmptyString ;
39152 wxString *arg5 = (wxString *) &arg5_defvalue ;
39153 wxMenuItem *result = 0 ;
39154 void *argp1 = 0 ;
39155 int res1 = 0 ;
39156 int val2 ;
39157 int ecode2 = 0 ;
39158 bool temp3 = false ;
39159 void *argp4 = 0 ;
39160 int res4 = 0 ;
39161 bool temp5 = false ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 PyObject * obj2 = 0 ;
39165 PyObject * obj3 = 0 ;
39166 PyObject * obj4 = 0 ;
39167 char * kwnames[] = {
39168 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39169 };
39170
39171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39173 if (!SWIG_IsOK(res1)) {
39174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39175 }
39176 arg1 = reinterpret_cast< wxMenu * >(argp1);
39177 ecode2 = SWIG_AsVal_int(obj1, &val2);
39178 if (!SWIG_IsOK(ecode2)) {
39179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39180 }
39181 arg2 = static_cast< int >(val2);
39182 {
39183 arg3 = wxString_in_helper(obj2);
39184 if (arg3 == NULL) SWIG_fail;
39185 temp3 = true;
39186 }
39187 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39188 if (!SWIG_IsOK(res4)) {
39189 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39190 }
39191 arg4 = reinterpret_cast< wxMenu * >(argp4);
39192 if (obj4) {
39193 {
39194 arg5 = wxString_in_helper(obj4);
39195 if (arg5 == NULL) SWIG_fail;
39196 temp5 = true;
39197 }
39198 }
39199 {
39200 PyThreadState* __tstate = wxPyBeginAllowThreads();
39201 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39202 wxPyEndAllowThreads(__tstate);
39203 if (PyErr_Occurred()) SWIG_fail;
39204 }
39205 {
39206 resultobj = wxPyMake_wxObject(result, (bool)0);
39207 }
39208 {
39209 if (temp3)
39210 delete arg3;
39211 }
39212 {
39213 if (temp5)
39214 delete arg5;
39215 }
39216 return resultobj;
39217 fail:
39218 {
39219 if (temp3)
39220 delete arg3;
39221 }
39222 {
39223 if (temp5)
39224 delete arg5;
39225 }
39226 return NULL;
39227 }
39228
39229
39230 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39231 PyObject *resultobj = 0;
39232 wxMenu *arg1 = (wxMenu *) 0 ;
39233 int arg2 ;
39234 wxMenuItem *result = 0 ;
39235 void *argp1 = 0 ;
39236 int res1 = 0 ;
39237 int val2 ;
39238 int ecode2 = 0 ;
39239 PyObject * obj0 = 0 ;
39240 PyObject * obj1 = 0 ;
39241 char * kwnames[] = {
39242 (char *) "self",(char *) "id", NULL
39243 };
39244
39245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39247 if (!SWIG_IsOK(res1)) {
39248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39249 }
39250 arg1 = reinterpret_cast< wxMenu * >(argp1);
39251 ecode2 = SWIG_AsVal_int(obj1, &val2);
39252 if (!SWIG_IsOK(ecode2)) {
39253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39254 }
39255 arg2 = static_cast< int >(val2);
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 result = (wxMenuItem *)(arg1)->Remove(arg2);
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 {
39263 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39264 }
39265 return resultobj;
39266 fail:
39267 return NULL;
39268 }
39269
39270
39271 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39272 PyObject *resultobj = 0;
39273 wxMenu *arg1 = (wxMenu *) 0 ;
39274 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39275 wxMenuItem *result = 0 ;
39276 void *argp1 = 0 ;
39277 int res1 = 0 ;
39278 void *argp2 = 0 ;
39279 int res2 = 0 ;
39280 PyObject * obj0 = 0 ;
39281 PyObject * obj1 = 0 ;
39282 char * kwnames[] = {
39283 (char *) "self",(char *) "item", NULL
39284 };
39285
39286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39288 if (!SWIG_IsOK(res1)) {
39289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39290 }
39291 arg1 = reinterpret_cast< wxMenu * >(argp1);
39292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39293 if (!SWIG_IsOK(res2)) {
39294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39295 }
39296 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39297 {
39298 PyThreadState* __tstate = wxPyBeginAllowThreads();
39299 result = (wxMenuItem *)(arg1)->Remove(arg2);
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 {
39304 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39305 }
39306 return resultobj;
39307 fail:
39308 return NULL;
39309 }
39310
39311
39312 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39313 PyObject *resultobj = 0;
39314 wxMenu *arg1 = (wxMenu *) 0 ;
39315 int arg2 ;
39316 bool result;
39317 void *argp1 = 0 ;
39318 int res1 = 0 ;
39319 int val2 ;
39320 int ecode2 = 0 ;
39321 PyObject * obj0 = 0 ;
39322 PyObject * obj1 = 0 ;
39323 char * kwnames[] = {
39324 (char *) "self",(char *) "id", NULL
39325 };
39326
39327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39331 }
39332 arg1 = reinterpret_cast< wxMenu * >(argp1);
39333 ecode2 = SWIG_AsVal_int(obj1, &val2);
39334 if (!SWIG_IsOK(ecode2)) {
39335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39336 }
39337 arg2 = static_cast< int >(val2);
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (bool)(arg1)->Delete(arg2);
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 {
39345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39346 }
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj = 0;
39355 wxMenu *arg1 = (wxMenu *) 0 ;
39356 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39357 bool result;
39358 void *argp1 = 0 ;
39359 int res1 = 0 ;
39360 void *argp2 = 0 ;
39361 int res2 = 0 ;
39362 PyObject * obj0 = 0 ;
39363 PyObject * obj1 = 0 ;
39364 char * kwnames[] = {
39365 (char *) "self",(char *) "item", NULL
39366 };
39367
39368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39370 if (!SWIG_IsOK(res1)) {
39371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39372 }
39373 arg1 = reinterpret_cast< wxMenu * >(argp1);
39374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39375 if (!SWIG_IsOK(res2)) {
39376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39377 }
39378 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 result = (bool)(arg1)->Delete(arg2);
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 {
39386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39387 }
39388 return resultobj;
39389 fail:
39390 return NULL;
39391 }
39392
39393
39394 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39395 PyObject *resultobj = 0;
39396 wxMenu *arg1 = (wxMenu *) 0 ;
39397 void *argp1 = 0 ;
39398 int res1 = 0 ;
39399 PyObject *swig_obj[1] ;
39400
39401 if (!args) SWIG_fail;
39402 swig_obj[0] = args;
39403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39404 if (!SWIG_IsOK(res1)) {
39405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39406 }
39407 arg1 = reinterpret_cast< wxMenu * >(argp1);
39408 {
39409 PyThreadState* __tstate = wxPyBeginAllowThreads();
39410 wxMenu_Destroy(arg1);
39411 wxPyEndAllowThreads(__tstate);
39412 if (PyErr_Occurred()) SWIG_fail;
39413 }
39414 resultobj = SWIG_Py_Void();
39415 return resultobj;
39416 fail:
39417 return NULL;
39418 }
39419
39420
39421 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39422 PyObject *resultobj = 0;
39423 wxMenu *arg1 = (wxMenu *) 0 ;
39424 int arg2 ;
39425 bool result;
39426 void *argp1 = 0 ;
39427 int res1 = 0 ;
39428 int val2 ;
39429 int ecode2 = 0 ;
39430 PyObject * obj0 = 0 ;
39431 PyObject * obj1 = 0 ;
39432 char * kwnames[] = {
39433 (char *) "self",(char *) "id", NULL
39434 };
39435
39436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39440 }
39441 arg1 = reinterpret_cast< wxMenu * >(argp1);
39442 ecode2 = SWIG_AsVal_int(obj1, &val2);
39443 if (!SWIG_IsOK(ecode2)) {
39444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39445 }
39446 arg2 = static_cast< int >(val2);
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 result = (bool)(arg1)->Destroy(arg2);
39450 wxPyEndAllowThreads(__tstate);
39451 if (PyErr_Occurred()) SWIG_fail;
39452 }
39453 {
39454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39455 }
39456 return resultobj;
39457 fail:
39458 return NULL;
39459 }
39460
39461
39462 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj = 0;
39464 wxMenu *arg1 = (wxMenu *) 0 ;
39465 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39466 bool result;
39467 void *argp1 = 0 ;
39468 int res1 = 0 ;
39469 void *argp2 = 0 ;
39470 int res2 = 0 ;
39471 PyObject * obj0 = 0 ;
39472 PyObject * obj1 = 0 ;
39473 char * kwnames[] = {
39474 (char *) "self",(char *) "item", NULL
39475 };
39476
39477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39479 if (!SWIG_IsOK(res1)) {
39480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39481 }
39482 arg1 = reinterpret_cast< wxMenu * >(argp1);
39483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39484 if (!SWIG_IsOK(res2)) {
39485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39486 }
39487 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39488 {
39489 PyThreadState* __tstate = wxPyBeginAllowThreads();
39490 result = (bool)(arg1)->Destroy(arg2);
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 {
39495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39496 }
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39504 PyObject *resultobj = 0;
39505 wxMenu *arg1 = (wxMenu *) 0 ;
39506 size_t result;
39507 void *argp1 = 0 ;
39508 int res1 = 0 ;
39509 PyObject *swig_obj[1] ;
39510
39511 if (!args) SWIG_fail;
39512 swig_obj[0] = args;
39513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39514 if (!SWIG_IsOK(res1)) {
39515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39516 }
39517 arg1 = reinterpret_cast< wxMenu * >(argp1);
39518 {
39519 PyThreadState* __tstate = wxPyBeginAllowThreads();
39520 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39521 wxPyEndAllowThreads(__tstate);
39522 if (PyErr_Occurred()) SWIG_fail;
39523 }
39524 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39525 return resultobj;
39526 fail:
39527 return NULL;
39528 }
39529
39530
39531 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39532 PyObject *resultobj = 0;
39533 wxMenu *arg1 = (wxMenu *) 0 ;
39534 PyObject *result = 0 ;
39535 void *argp1 = 0 ;
39536 int res1 = 0 ;
39537 PyObject *swig_obj[1] ;
39538
39539 if (!args) SWIG_fail;
39540 swig_obj[0] = args;
39541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39542 if (!SWIG_IsOK(res1)) {
39543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39544 }
39545 arg1 = reinterpret_cast< wxMenu * >(argp1);
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 resultobj = result;
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39560 PyObject *resultobj = 0;
39561 wxMenu *arg1 = (wxMenu *) 0 ;
39562 wxString *arg2 = 0 ;
39563 int result;
39564 void *argp1 = 0 ;
39565 int res1 = 0 ;
39566 bool temp2 = false ;
39567 PyObject * obj0 = 0 ;
39568 PyObject * obj1 = 0 ;
39569 char * kwnames[] = {
39570 (char *) "self",(char *) "item", NULL
39571 };
39572
39573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39575 if (!SWIG_IsOK(res1)) {
39576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39577 }
39578 arg1 = reinterpret_cast< wxMenu * >(argp1);
39579 {
39580 arg2 = wxString_in_helper(obj1);
39581 if (arg2 == NULL) SWIG_fail;
39582 temp2 = true;
39583 }
39584 {
39585 PyThreadState* __tstate = wxPyBeginAllowThreads();
39586 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39587 wxPyEndAllowThreads(__tstate);
39588 if (PyErr_Occurred()) SWIG_fail;
39589 }
39590 resultobj = SWIG_From_int(static_cast< int >(result));
39591 {
39592 if (temp2)
39593 delete arg2;
39594 }
39595 return resultobj;
39596 fail:
39597 {
39598 if (temp2)
39599 delete arg2;
39600 }
39601 return NULL;
39602 }
39603
39604
39605 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39606 PyObject *resultobj = 0;
39607 wxMenu *arg1 = (wxMenu *) 0 ;
39608 int arg2 ;
39609 wxMenuItem *result = 0 ;
39610 void *argp1 = 0 ;
39611 int res1 = 0 ;
39612 int val2 ;
39613 int ecode2 = 0 ;
39614 PyObject * obj0 = 0 ;
39615 PyObject * obj1 = 0 ;
39616 char * kwnames[] = {
39617 (char *) "self",(char *) "id", NULL
39618 };
39619
39620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39622 if (!SWIG_IsOK(res1)) {
39623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39624 }
39625 arg1 = reinterpret_cast< wxMenu * >(argp1);
39626 ecode2 = SWIG_AsVal_int(obj1, &val2);
39627 if (!SWIG_IsOK(ecode2)) {
39628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39629 }
39630 arg2 = static_cast< int >(val2);
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 resultobj = wxPyMake_wxObject(result, (bool)0);
39639 }
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39647 PyObject *resultobj = 0;
39648 wxMenu *arg1 = (wxMenu *) 0 ;
39649 size_t arg2 ;
39650 wxMenuItem *result = 0 ;
39651 void *argp1 = 0 ;
39652 int res1 = 0 ;
39653 size_t val2 ;
39654 int ecode2 = 0 ;
39655 PyObject * obj0 = 0 ;
39656 PyObject * obj1 = 0 ;
39657 char * kwnames[] = {
39658 (char *) "self",(char *) "position", NULL
39659 };
39660
39661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39663 if (!SWIG_IsOK(res1)) {
39664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39665 }
39666 arg1 = reinterpret_cast< wxMenu * >(argp1);
39667 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39668 if (!SWIG_IsOK(ecode2)) {
39669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39670 }
39671 arg2 = static_cast< size_t >(val2);
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 {
39679 resultobj = wxPyMake_wxObject(result, (bool)0);
39680 }
39681 return resultobj;
39682 fail:
39683 return NULL;
39684 }
39685
39686
39687 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39688 PyObject *resultobj = 0;
39689 wxMenu *arg1 = (wxMenu *) 0 ;
39690 int arg2 ;
39691 bool arg3 ;
39692 void *argp1 = 0 ;
39693 int res1 = 0 ;
39694 int val2 ;
39695 int ecode2 = 0 ;
39696 bool val3 ;
39697 int ecode3 = 0 ;
39698 PyObject * obj0 = 0 ;
39699 PyObject * obj1 = 0 ;
39700 PyObject * obj2 = 0 ;
39701 char * kwnames[] = {
39702 (char *) "self",(char *) "id",(char *) "enable", NULL
39703 };
39704
39705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39707 if (!SWIG_IsOK(res1)) {
39708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39709 }
39710 arg1 = reinterpret_cast< wxMenu * >(argp1);
39711 ecode2 = SWIG_AsVal_int(obj1, &val2);
39712 if (!SWIG_IsOK(ecode2)) {
39713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39714 }
39715 arg2 = static_cast< int >(val2);
39716 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39717 if (!SWIG_IsOK(ecode3)) {
39718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39719 }
39720 arg3 = static_cast< bool >(val3);
39721 {
39722 PyThreadState* __tstate = wxPyBeginAllowThreads();
39723 (arg1)->Enable(arg2,arg3);
39724 wxPyEndAllowThreads(__tstate);
39725 if (PyErr_Occurred()) SWIG_fail;
39726 }
39727 resultobj = SWIG_Py_Void();
39728 return resultobj;
39729 fail:
39730 return NULL;
39731 }
39732
39733
39734 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39735 PyObject *resultobj = 0;
39736 wxMenu *arg1 = (wxMenu *) 0 ;
39737 int arg2 ;
39738 bool result;
39739 void *argp1 = 0 ;
39740 int res1 = 0 ;
39741 int val2 ;
39742 int ecode2 = 0 ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "id", NULL
39747 };
39748
39749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39751 if (!SWIG_IsOK(res1)) {
39752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39753 }
39754 arg1 = reinterpret_cast< wxMenu * >(argp1);
39755 ecode2 = SWIG_AsVal_int(obj1, &val2);
39756 if (!SWIG_IsOK(ecode2)) {
39757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39758 }
39759 arg2 = static_cast< int >(val2);
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39768 }
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = 0;
39777 wxMenu *arg1 = (wxMenu *) 0 ;
39778 int arg2 ;
39779 bool arg3 ;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 int val2 ;
39783 int ecode2 = 0 ;
39784 bool val3 ;
39785 int ecode3 = 0 ;
39786 PyObject * obj0 = 0 ;
39787 PyObject * obj1 = 0 ;
39788 PyObject * obj2 = 0 ;
39789 char * kwnames[] = {
39790 (char *) "self",(char *) "id",(char *) "check", NULL
39791 };
39792
39793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39795 if (!SWIG_IsOK(res1)) {
39796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39797 }
39798 arg1 = reinterpret_cast< wxMenu * >(argp1);
39799 ecode2 = SWIG_AsVal_int(obj1, &val2);
39800 if (!SWIG_IsOK(ecode2)) {
39801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39802 }
39803 arg2 = static_cast< int >(val2);
39804 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39805 if (!SWIG_IsOK(ecode3)) {
39806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39807 }
39808 arg3 = static_cast< bool >(val3);
39809 {
39810 PyThreadState* __tstate = wxPyBeginAllowThreads();
39811 (arg1)->Check(arg2,arg3);
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 resultobj = SWIG_Py_Void();
39816 return resultobj;
39817 fail:
39818 return NULL;
39819 }
39820
39821
39822 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj = 0;
39824 wxMenu *arg1 = (wxMenu *) 0 ;
39825 int arg2 ;
39826 bool result;
39827 void *argp1 = 0 ;
39828 int res1 = 0 ;
39829 int val2 ;
39830 int ecode2 = 0 ;
39831 PyObject * obj0 = 0 ;
39832 PyObject * obj1 = 0 ;
39833 char * kwnames[] = {
39834 (char *) "self",(char *) "id", NULL
39835 };
39836
39837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res1)) {
39840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39841 }
39842 arg1 = reinterpret_cast< wxMenu * >(argp1);
39843 ecode2 = SWIG_AsVal_int(obj1, &val2);
39844 if (!SWIG_IsOK(ecode2)) {
39845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39846 }
39847 arg2 = static_cast< int >(val2);
39848 {
39849 PyThreadState* __tstate = wxPyBeginAllowThreads();
39850 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39851 wxPyEndAllowThreads(__tstate);
39852 if (PyErr_Occurred()) SWIG_fail;
39853 }
39854 {
39855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39856 }
39857 return resultobj;
39858 fail:
39859 return NULL;
39860 }
39861
39862
39863 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39864 PyObject *resultobj = 0;
39865 wxMenu *arg1 = (wxMenu *) 0 ;
39866 int arg2 ;
39867 wxString *arg3 = 0 ;
39868 void *argp1 = 0 ;
39869 int res1 = 0 ;
39870 int val2 ;
39871 int ecode2 = 0 ;
39872 bool temp3 = false ;
39873 PyObject * obj0 = 0 ;
39874 PyObject * obj1 = 0 ;
39875 PyObject * obj2 = 0 ;
39876 char * kwnames[] = {
39877 (char *) "self",(char *) "id",(char *) "label", NULL
39878 };
39879
39880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39882 if (!SWIG_IsOK(res1)) {
39883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39884 }
39885 arg1 = reinterpret_cast< wxMenu * >(argp1);
39886 ecode2 = SWIG_AsVal_int(obj1, &val2);
39887 if (!SWIG_IsOK(ecode2)) {
39888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39889 }
39890 arg2 = static_cast< int >(val2);
39891 {
39892 arg3 = wxString_in_helper(obj2);
39893 if (arg3 == NULL) SWIG_fail;
39894 temp3 = true;
39895 }
39896 {
39897 PyThreadState* __tstate = wxPyBeginAllowThreads();
39898 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39899 wxPyEndAllowThreads(__tstate);
39900 if (PyErr_Occurred()) SWIG_fail;
39901 }
39902 resultobj = SWIG_Py_Void();
39903 {
39904 if (temp3)
39905 delete arg3;
39906 }
39907 return resultobj;
39908 fail:
39909 {
39910 if (temp3)
39911 delete arg3;
39912 }
39913 return NULL;
39914 }
39915
39916
39917 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39918 PyObject *resultobj = 0;
39919 wxMenu *arg1 = (wxMenu *) 0 ;
39920 int arg2 ;
39921 wxString result;
39922 void *argp1 = 0 ;
39923 int res1 = 0 ;
39924 int val2 ;
39925 int ecode2 = 0 ;
39926 PyObject * obj0 = 0 ;
39927 PyObject * obj1 = 0 ;
39928 char * kwnames[] = {
39929 (char *) "self",(char *) "id", NULL
39930 };
39931
39932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res1)) {
39935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39936 }
39937 arg1 = reinterpret_cast< wxMenu * >(argp1);
39938 ecode2 = SWIG_AsVal_int(obj1, &val2);
39939 if (!SWIG_IsOK(ecode2)) {
39940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39941 }
39942 arg2 = static_cast< int >(val2);
39943 {
39944 PyThreadState* __tstate = wxPyBeginAllowThreads();
39945 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39946 wxPyEndAllowThreads(__tstate);
39947 if (PyErr_Occurred()) SWIG_fail;
39948 }
39949 {
39950 #if wxUSE_UNICODE
39951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39952 #else
39953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39954 #endif
39955 }
39956 return resultobj;
39957 fail:
39958 return NULL;
39959 }
39960
39961
39962 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39963 PyObject *resultobj = 0;
39964 wxMenu *arg1 = (wxMenu *) 0 ;
39965 int arg2 ;
39966 wxString *arg3 = 0 ;
39967 void *argp1 = 0 ;
39968 int res1 = 0 ;
39969 int val2 ;
39970 int ecode2 = 0 ;
39971 bool temp3 = false ;
39972 PyObject * obj0 = 0 ;
39973 PyObject * obj1 = 0 ;
39974 PyObject * obj2 = 0 ;
39975 char * kwnames[] = {
39976 (char *) "self",(char *) "id",(char *) "helpString", NULL
39977 };
39978
39979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39981 if (!SWIG_IsOK(res1)) {
39982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
39983 }
39984 arg1 = reinterpret_cast< wxMenu * >(argp1);
39985 ecode2 = SWIG_AsVal_int(obj1, &val2);
39986 if (!SWIG_IsOK(ecode2)) {
39987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
39988 }
39989 arg2 = static_cast< int >(val2);
39990 {
39991 arg3 = wxString_in_helper(obj2);
39992 if (arg3 == NULL) SWIG_fail;
39993 temp3 = true;
39994 }
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 resultobj = SWIG_Py_Void();
40002 {
40003 if (temp3)
40004 delete arg3;
40005 }
40006 return resultobj;
40007 fail:
40008 {
40009 if (temp3)
40010 delete arg3;
40011 }
40012 return NULL;
40013 }
40014
40015
40016 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40017 PyObject *resultobj = 0;
40018 wxMenu *arg1 = (wxMenu *) 0 ;
40019 int arg2 ;
40020 wxString result;
40021 void *argp1 = 0 ;
40022 int res1 = 0 ;
40023 int val2 ;
40024 int ecode2 = 0 ;
40025 PyObject * obj0 = 0 ;
40026 PyObject * obj1 = 0 ;
40027 char * kwnames[] = {
40028 (char *) "self",(char *) "id", NULL
40029 };
40030
40031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40035 }
40036 arg1 = reinterpret_cast< wxMenu * >(argp1);
40037 ecode2 = SWIG_AsVal_int(obj1, &val2);
40038 if (!SWIG_IsOK(ecode2)) {
40039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40040 }
40041 arg2 = static_cast< int >(val2);
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40045 wxPyEndAllowThreads(__tstate);
40046 if (PyErr_Occurred()) SWIG_fail;
40047 }
40048 {
40049 #if wxUSE_UNICODE
40050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40051 #else
40052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40053 #endif
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40062 PyObject *resultobj = 0;
40063 wxMenu *arg1 = (wxMenu *) 0 ;
40064 wxString *arg2 = 0 ;
40065 void *argp1 = 0 ;
40066 int res1 = 0 ;
40067 bool temp2 = false ;
40068 PyObject * obj0 = 0 ;
40069 PyObject * obj1 = 0 ;
40070 char * kwnames[] = {
40071 (char *) "self",(char *) "title", NULL
40072 };
40073
40074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40076 if (!SWIG_IsOK(res1)) {
40077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40078 }
40079 arg1 = reinterpret_cast< wxMenu * >(argp1);
40080 {
40081 arg2 = wxString_in_helper(obj1);
40082 if (arg2 == NULL) SWIG_fail;
40083 temp2 = true;
40084 }
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 (arg1)->SetTitle((wxString const &)*arg2);
40088 wxPyEndAllowThreads(__tstate);
40089 if (PyErr_Occurred()) SWIG_fail;
40090 }
40091 resultobj = SWIG_Py_Void();
40092 {
40093 if (temp2)
40094 delete arg2;
40095 }
40096 return resultobj;
40097 fail:
40098 {
40099 if (temp2)
40100 delete arg2;
40101 }
40102 return NULL;
40103 }
40104
40105
40106 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40107 PyObject *resultobj = 0;
40108 wxMenu *arg1 = (wxMenu *) 0 ;
40109 wxString result;
40110 void *argp1 = 0 ;
40111 int res1 = 0 ;
40112 PyObject *swig_obj[1] ;
40113
40114 if (!args) SWIG_fail;
40115 swig_obj[0] = args;
40116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40117 if (!SWIG_IsOK(res1)) {
40118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40119 }
40120 arg1 = reinterpret_cast< wxMenu * >(argp1);
40121 {
40122 PyThreadState* __tstate = wxPyBeginAllowThreads();
40123 result = ((wxMenu const *)arg1)->GetTitle();
40124 wxPyEndAllowThreads(__tstate);
40125 if (PyErr_Occurred()) SWIG_fail;
40126 }
40127 {
40128 #if wxUSE_UNICODE
40129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40130 #else
40131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40132 #endif
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj = 0;
40142 wxMenu *arg1 = (wxMenu *) 0 ;
40143 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40144 void *argp1 = 0 ;
40145 int res1 = 0 ;
40146 void *argp2 = 0 ;
40147 int res2 = 0 ;
40148 PyObject * obj0 = 0 ;
40149 PyObject * obj1 = 0 ;
40150 char * kwnames[] = {
40151 (char *) "self",(char *) "handler", NULL
40152 };
40153
40154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40156 if (!SWIG_IsOK(res1)) {
40157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40158 }
40159 arg1 = reinterpret_cast< wxMenu * >(argp1);
40160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40161 if (!SWIG_IsOK(res2)) {
40162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40163 }
40164 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40165 {
40166 PyThreadState* __tstate = wxPyBeginAllowThreads();
40167 (arg1)->SetEventHandler(arg2);
40168 wxPyEndAllowThreads(__tstate);
40169 if (PyErr_Occurred()) SWIG_fail;
40170 }
40171 resultobj = SWIG_Py_Void();
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40179 PyObject *resultobj = 0;
40180 wxMenu *arg1 = (wxMenu *) 0 ;
40181 wxEvtHandler *result = 0 ;
40182 void *argp1 = 0 ;
40183 int res1 = 0 ;
40184 PyObject *swig_obj[1] ;
40185
40186 if (!args) SWIG_fail;
40187 swig_obj[0] = args;
40188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40191 }
40192 arg1 = reinterpret_cast< wxMenu * >(argp1);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 {
40200 resultobj = wxPyMake_wxObject(result, 0);
40201 }
40202 return resultobj;
40203 fail:
40204 return NULL;
40205 }
40206
40207
40208 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40209 PyObject *resultobj = 0;
40210 wxMenu *arg1 = (wxMenu *) 0 ;
40211 wxWindow *arg2 = (wxWindow *) 0 ;
40212 void *argp1 = 0 ;
40213 int res1 = 0 ;
40214 void *argp2 = 0 ;
40215 int res2 = 0 ;
40216 PyObject * obj0 = 0 ;
40217 PyObject * obj1 = 0 ;
40218 char * kwnames[] = {
40219 (char *) "self",(char *) "win", NULL
40220 };
40221
40222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40224 if (!SWIG_IsOK(res1)) {
40225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40226 }
40227 arg1 = reinterpret_cast< wxMenu * >(argp1);
40228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40229 if (!SWIG_IsOK(res2)) {
40230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40231 }
40232 arg2 = reinterpret_cast< wxWindow * >(argp2);
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 (arg1)->SetInvokingWindow(arg2);
40236 wxPyEndAllowThreads(__tstate);
40237 if (PyErr_Occurred()) SWIG_fail;
40238 }
40239 resultobj = SWIG_Py_Void();
40240 return resultobj;
40241 fail:
40242 return NULL;
40243 }
40244
40245
40246 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40247 PyObject *resultobj = 0;
40248 wxMenu *arg1 = (wxMenu *) 0 ;
40249 wxWindow *result = 0 ;
40250 void *argp1 = 0 ;
40251 int res1 = 0 ;
40252 PyObject *swig_obj[1] ;
40253
40254 if (!args) SWIG_fail;
40255 swig_obj[0] = args;
40256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40257 if (!SWIG_IsOK(res1)) {
40258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40259 }
40260 arg1 = reinterpret_cast< wxMenu * >(argp1);
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 {
40268 resultobj = wxPyMake_wxObject(result, 0);
40269 }
40270 return resultobj;
40271 fail:
40272 return NULL;
40273 }
40274
40275
40276 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40277 PyObject *resultobj = 0;
40278 wxMenu *arg1 = (wxMenu *) 0 ;
40279 long result;
40280 void *argp1 = 0 ;
40281 int res1 = 0 ;
40282 PyObject *swig_obj[1] ;
40283
40284 if (!args) SWIG_fail;
40285 swig_obj[0] = args;
40286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40287 if (!SWIG_IsOK(res1)) {
40288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40289 }
40290 arg1 = reinterpret_cast< wxMenu * >(argp1);
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 result = (long)((wxMenu const *)arg1)->GetStyle();
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 resultobj = SWIG_From_long(static_cast< long >(result));
40298 return resultobj;
40299 fail:
40300 return NULL;
40301 }
40302
40303
40304 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40305 PyObject *resultobj = 0;
40306 wxMenu *arg1 = (wxMenu *) 0 ;
40307 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40308 void *argp1 = 0 ;
40309 int res1 = 0 ;
40310 void *argp2 = 0 ;
40311 int res2 = 0 ;
40312 PyObject * obj0 = 0 ;
40313 PyObject * obj1 = 0 ;
40314 char * kwnames[] = {
40315 (char *) "self",(char *) "source", NULL
40316 };
40317
40318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40320 if (!SWIG_IsOK(res1)) {
40321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40322 }
40323 arg1 = reinterpret_cast< wxMenu * >(argp1);
40324 if (obj1) {
40325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40326 if (!SWIG_IsOK(res2)) {
40327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40328 }
40329 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40330 }
40331 {
40332 PyThreadState* __tstate = wxPyBeginAllowThreads();
40333 (arg1)->UpdateUI(arg2);
40334 wxPyEndAllowThreads(__tstate);
40335 if (PyErr_Occurred()) SWIG_fail;
40336 }
40337 resultobj = SWIG_Py_Void();
40338 return resultobj;
40339 fail:
40340 return NULL;
40341 }
40342
40343
40344 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40345 PyObject *resultobj = 0;
40346 wxMenu *arg1 = (wxMenu *) 0 ;
40347 wxMenuBar *result = 0 ;
40348 void *argp1 = 0 ;
40349 int res1 = 0 ;
40350 PyObject *swig_obj[1] ;
40351
40352 if (!args) SWIG_fail;
40353 swig_obj[0] = args;
40354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40355 if (!SWIG_IsOK(res1)) {
40356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40357 }
40358 arg1 = reinterpret_cast< wxMenu * >(argp1);
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 {
40366 resultobj = wxPyMake_wxObject(result, (bool)0);
40367 }
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj = 0;
40376 wxMenu *arg1 = (wxMenu *) 0 ;
40377 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40378 void *argp1 = 0 ;
40379 int res1 = 0 ;
40380 void *argp2 = 0 ;
40381 int res2 = 0 ;
40382 PyObject * obj0 = 0 ;
40383 PyObject * obj1 = 0 ;
40384 char * kwnames[] = {
40385 (char *) "self",(char *) "menubar", NULL
40386 };
40387
40388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40390 if (!SWIG_IsOK(res1)) {
40391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40392 }
40393 arg1 = reinterpret_cast< wxMenu * >(argp1);
40394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40395 if (!SWIG_IsOK(res2)) {
40396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40397 }
40398 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40399 {
40400 PyThreadState* __tstate = wxPyBeginAllowThreads();
40401 (arg1)->Attach(arg2);
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 resultobj = SWIG_Py_Void();
40406 return resultobj;
40407 fail:
40408 return NULL;
40409 }
40410
40411
40412 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40413 PyObject *resultobj = 0;
40414 wxMenu *arg1 = (wxMenu *) 0 ;
40415 void *argp1 = 0 ;
40416 int res1 = 0 ;
40417 PyObject *swig_obj[1] ;
40418
40419 if (!args) SWIG_fail;
40420 swig_obj[0] = args;
40421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40422 if (!SWIG_IsOK(res1)) {
40423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40424 }
40425 arg1 = reinterpret_cast< wxMenu * >(argp1);
40426 {
40427 PyThreadState* __tstate = wxPyBeginAllowThreads();
40428 (arg1)->Detach();
40429 wxPyEndAllowThreads(__tstate);
40430 if (PyErr_Occurred()) SWIG_fail;
40431 }
40432 resultobj = SWIG_Py_Void();
40433 return resultobj;
40434 fail:
40435 return NULL;
40436 }
40437
40438
40439 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40440 PyObject *resultobj = 0;
40441 wxMenu *arg1 = (wxMenu *) 0 ;
40442 bool result;
40443 void *argp1 = 0 ;
40444 int res1 = 0 ;
40445 PyObject *swig_obj[1] ;
40446
40447 if (!args) SWIG_fail;
40448 swig_obj[0] = args;
40449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40450 if (!SWIG_IsOK(res1)) {
40451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40452 }
40453 arg1 = reinterpret_cast< wxMenu * >(argp1);
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 result = (bool)((wxMenu const *)arg1)->IsAttached();
40457 wxPyEndAllowThreads(__tstate);
40458 if (PyErr_Occurred()) SWIG_fail;
40459 }
40460 {
40461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40462 }
40463 return resultobj;
40464 fail:
40465 return NULL;
40466 }
40467
40468
40469 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40470 PyObject *resultobj = 0;
40471 wxMenu *arg1 = (wxMenu *) 0 ;
40472 wxMenu *arg2 = (wxMenu *) 0 ;
40473 void *argp1 = 0 ;
40474 int res1 = 0 ;
40475 void *argp2 = 0 ;
40476 int res2 = 0 ;
40477 PyObject * obj0 = 0 ;
40478 PyObject * obj1 = 0 ;
40479 char * kwnames[] = {
40480 (char *) "self",(char *) "parent", NULL
40481 };
40482
40483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40485 if (!SWIG_IsOK(res1)) {
40486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40487 }
40488 arg1 = reinterpret_cast< wxMenu * >(argp1);
40489 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40490 if (!SWIG_IsOK(res2)) {
40491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40492 }
40493 arg2 = reinterpret_cast< wxMenu * >(argp2);
40494 {
40495 PyThreadState* __tstate = wxPyBeginAllowThreads();
40496 (arg1)->SetParent(arg2);
40497 wxPyEndAllowThreads(__tstate);
40498 if (PyErr_Occurred()) SWIG_fail;
40499 }
40500 resultobj = SWIG_Py_Void();
40501 return resultobj;
40502 fail:
40503 return NULL;
40504 }
40505
40506
40507 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40508 PyObject *resultobj = 0;
40509 wxMenu *arg1 = (wxMenu *) 0 ;
40510 wxMenu *result = 0 ;
40511 void *argp1 = 0 ;
40512 int res1 = 0 ;
40513 PyObject *swig_obj[1] ;
40514
40515 if (!args) SWIG_fail;
40516 swig_obj[0] = args;
40517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40518 if (!SWIG_IsOK(res1)) {
40519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40520 }
40521 arg1 = reinterpret_cast< wxMenu * >(argp1);
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 {
40529 resultobj = wxPyMake_wxObject(result, 0);
40530 }
40531 return resultobj;
40532 fail:
40533 return NULL;
40534 }
40535
40536
40537 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40538 PyObject *obj;
40539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40540 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40541 return SWIG_Py_Void();
40542 }
40543
40544 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40545 return SWIG_Python_InitShadowInstance(args);
40546 }
40547
40548 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40549 PyObject *resultobj = 0;
40550 long arg1 = (long) 0 ;
40551 wxMenuBar *result = 0 ;
40552 long val1 ;
40553 int ecode1 = 0 ;
40554 PyObject * obj0 = 0 ;
40555 char * kwnames[] = {
40556 (char *) "style", NULL
40557 };
40558
40559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40560 if (obj0) {
40561 ecode1 = SWIG_AsVal_long(obj0, &val1);
40562 if (!SWIG_IsOK(ecode1)) {
40563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40564 }
40565 arg1 = static_cast< long >(val1);
40566 }
40567 {
40568 if (!wxPyCheckForApp()) SWIG_fail;
40569 PyThreadState* __tstate = wxPyBeginAllowThreads();
40570 result = (wxMenuBar *)new wxMenuBar(arg1);
40571 wxPyEndAllowThreads(__tstate);
40572 if (PyErr_Occurred()) SWIG_fail;
40573 }
40574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40575 return resultobj;
40576 fail:
40577 return NULL;
40578 }
40579
40580
40581 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj = 0;
40583 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40584 wxMenu *arg2 = (wxMenu *) 0 ;
40585 wxString *arg3 = 0 ;
40586 bool result;
40587 void *argp1 = 0 ;
40588 int res1 = 0 ;
40589 void *argp2 = 0 ;
40590 int res2 = 0 ;
40591 bool temp3 = false ;
40592 PyObject * obj0 = 0 ;
40593 PyObject * obj1 = 0 ;
40594 PyObject * obj2 = 0 ;
40595 char * kwnames[] = {
40596 (char *) "self",(char *) "menu",(char *) "title", NULL
40597 };
40598
40599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40601 if (!SWIG_IsOK(res1)) {
40602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40603 }
40604 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40606 if (!SWIG_IsOK(res2)) {
40607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40608 }
40609 arg2 = reinterpret_cast< wxMenu * >(argp2);
40610 {
40611 arg3 = wxString_in_helper(obj2);
40612 if (arg3 == NULL) SWIG_fail;
40613 temp3 = true;
40614 }
40615 {
40616 PyThreadState* __tstate = wxPyBeginAllowThreads();
40617 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 {
40622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40623 }
40624 {
40625 if (temp3)
40626 delete arg3;
40627 }
40628 return resultobj;
40629 fail:
40630 {
40631 if (temp3)
40632 delete arg3;
40633 }
40634 return NULL;
40635 }
40636
40637
40638 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40639 PyObject *resultobj = 0;
40640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40641 size_t arg2 ;
40642 wxMenu *arg3 = (wxMenu *) 0 ;
40643 wxString *arg4 = 0 ;
40644 bool result;
40645 void *argp1 = 0 ;
40646 int res1 = 0 ;
40647 size_t val2 ;
40648 int ecode2 = 0 ;
40649 void *argp3 = 0 ;
40650 int res3 = 0 ;
40651 bool temp4 = false ;
40652 PyObject * obj0 = 0 ;
40653 PyObject * obj1 = 0 ;
40654 PyObject * obj2 = 0 ;
40655 PyObject * obj3 = 0 ;
40656 char * kwnames[] = {
40657 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40658 };
40659
40660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40662 if (!SWIG_IsOK(res1)) {
40663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40664 }
40665 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40666 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40667 if (!SWIG_IsOK(ecode2)) {
40668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40669 }
40670 arg2 = static_cast< size_t >(val2);
40671 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40672 if (!SWIG_IsOK(res3)) {
40673 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40674 }
40675 arg3 = reinterpret_cast< wxMenu * >(argp3);
40676 {
40677 arg4 = wxString_in_helper(obj3);
40678 if (arg4 == NULL) SWIG_fail;
40679 temp4 = true;
40680 }
40681 {
40682 PyThreadState* __tstate = wxPyBeginAllowThreads();
40683 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40684 wxPyEndAllowThreads(__tstate);
40685 if (PyErr_Occurred()) SWIG_fail;
40686 }
40687 {
40688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40689 }
40690 {
40691 if (temp4)
40692 delete arg4;
40693 }
40694 return resultobj;
40695 fail:
40696 {
40697 if (temp4)
40698 delete arg4;
40699 }
40700 return NULL;
40701 }
40702
40703
40704 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40705 PyObject *resultobj = 0;
40706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40707 size_t result;
40708 void *argp1 = 0 ;
40709 int res1 = 0 ;
40710 PyObject *swig_obj[1] ;
40711
40712 if (!args) SWIG_fail;
40713 swig_obj[0] = args;
40714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40715 if (!SWIG_IsOK(res1)) {
40716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40717 }
40718 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40719 {
40720 PyThreadState* __tstate = wxPyBeginAllowThreads();
40721 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40722 wxPyEndAllowThreads(__tstate);
40723 if (PyErr_Occurred()) SWIG_fail;
40724 }
40725 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj = 0;
40734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40735 size_t arg2 ;
40736 wxMenu *result = 0 ;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 size_t val2 ;
40740 int ecode2 = 0 ;
40741 PyObject * obj0 = 0 ;
40742 PyObject * obj1 = 0 ;
40743 char * kwnames[] = {
40744 (char *) "self",(char *) "pos", NULL
40745 };
40746
40747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40749 if (!SWIG_IsOK(res1)) {
40750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40751 }
40752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40753 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40754 if (!SWIG_IsOK(ecode2)) {
40755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40756 }
40757 arg2 = static_cast< size_t >(val2);
40758 {
40759 PyThreadState* __tstate = wxPyBeginAllowThreads();
40760 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40761 wxPyEndAllowThreads(__tstate);
40762 if (PyErr_Occurred()) SWIG_fail;
40763 }
40764 {
40765 resultobj = wxPyMake_wxObject(result, 0);
40766 }
40767 return resultobj;
40768 fail:
40769 return NULL;
40770 }
40771
40772
40773 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj = 0;
40775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40776 size_t arg2 ;
40777 wxMenu *arg3 = (wxMenu *) 0 ;
40778 wxString *arg4 = 0 ;
40779 wxMenu *result = 0 ;
40780 void *argp1 = 0 ;
40781 int res1 = 0 ;
40782 size_t val2 ;
40783 int ecode2 = 0 ;
40784 void *argp3 = 0 ;
40785 int res3 = 0 ;
40786 bool temp4 = false ;
40787 PyObject * obj0 = 0 ;
40788 PyObject * obj1 = 0 ;
40789 PyObject * obj2 = 0 ;
40790 PyObject * obj3 = 0 ;
40791 char * kwnames[] = {
40792 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40793 };
40794
40795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40797 if (!SWIG_IsOK(res1)) {
40798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40799 }
40800 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40801 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40802 if (!SWIG_IsOK(ecode2)) {
40803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40804 }
40805 arg2 = static_cast< size_t >(val2);
40806 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40807 if (!SWIG_IsOK(res3)) {
40808 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40809 }
40810 arg3 = reinterpret_cast< wxMenu * >(argp3);
40811 {
40812 arg4 = wxString_in_helper(obj3);
40813 if (arg4 == NULL) SWIG_fail;
40814 temp4 = true;
40815 }
40816 {
40817 PyThreadState* __tstate = wxPyBeginAllowThreads();
40818 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 {
40823 resultobj = wxPyMake_wxObject(result, 0);
40824 }
40825 {
40826 if (temp4)
40827 delete arg4;
40828 }
40829 return resultobj;
40830 fail:
40831 {
40832 if (temp4)
40833 delete arg4;
40834 }
40835 return NULL;
40836 }
40837
40838
40839 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj = 0;
40841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40842 size_t arg2 ;
40843 wxMenu *result = 0 ;
40844 void *argp1 = 0 ;
40845 int res1 = 0 ;
40846 size_t val2 ;
40847 int ecode2 = 0 ;
40848 PyObject * obj0 = 0 ;
40849 PyObject * obj1 = 0 ;
40850 char * kwnames[] = {
40851 (char *) "self",(char *) "pos", NULL
40852 };
40853
40854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40858 }
40859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40860 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40861 if (!SWIG_IsOK(ecode2)) {
40862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40863 }
40864 arg2 = static_cast< size_t >(val2);
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 result = (wxMenu *)(arg1)->Remove(arg2);
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 {
40872 resultobj = wxPyMake_wxObject(result, 0);
40873 }
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40881 PyObject *resultobj = 0;
40882 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40883 size_t arg2 ;
40884 bool arg3 ;
40885 void *argp1 = 0 ;
40886 int res1 = 0 ;
40887 size_t val2 ;
40888 int ecode2 = 0 ;
40889 bool val3 ;
40890 int ecode3 = 0 ;
40891 PyObject * obj0 = 0 ;
40892 PyObject * obj1 = 0 ;
40893 PyObject * obj2 = 0 ;
40894 char * kwnames[] = {
40895 (char *) "self",(char *) "pos",(char *) "enable", NULL
40896 };
40897
40898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40900 if (!SWIG_IsOK(res1)) {
40901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40902 }
40903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40905 if (!SWIG_IsOK(ecode2)) {
40906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40907 }
40908 arg2 = static_cast< size_t >(val2);
40909 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40910 if (!SWIG_IsOK(ecode3)) {
40911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40912 }
40913 arg3 = static_cast< bool >(val3);
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 (arg1)->EnableTop(arg2,arg3);
40917 wxPyEndAllowThreads(__tstate);
40918 if (PyErr_Occurred()) SWIG_fail;
40919 }
40920 resultobj = SWIG_Py_Void();
40921 return resultobj;
40922 fail:
40923 return NULL;
40924 }
40925
40926
40927 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40928 PyObject *resultobj = 0;
40929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40930 size_t arg2 ;
40931 bool result;
40932 void *argp1 = 0 ;
40933 int res1 = 0 ;
40934 size_t val2 ;
40935 int ecode2 = 0 ;
40936 PyObject * obj0 = 0 ;
40937 PyObject * obj1 = 0 ;
40938 char * kwnames[] = {
40939 (char *) "self",(char *) "pos", NULL
40940 };
40941
40942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40944 if (!SWIG_IsOK(res1)) {
40945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40946 }
40947 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40948 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40949 if (!SWIG_IsOK(ecode2)) {
40950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40951 }
40952 arg2 = static_cast< size_t >(val2);
40953 {
40954 PyThreadState* __tstate = wxPyBeginAllowThreads();
40955 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 {
40960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40961 }
40962 return resultobj;
40963 fail:
40964 return NULL;
40965 }
40966
40967
40968 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40969 PyObject *resultobj = 0;
40970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40971 size_t arg2 ;
40972 wxString *arg3 = 0 ;
40973 void *argp1 = 0 ;
40974 int res1 = 0 ;
40975 size_t val2 ;
40976 int ecode2 = 0 ;
40977 bool temp3 = false ;
40978 PyObject * obj0 = 0 ;
40979 PyObject * obj1 = 0 ;
40980 PyObject * obj2 = 0 ;
40981 char * kwnames[] = {
40982 (char *) "self",(char *) "pos",(char *) "label", NULL
40983 };
40984
40985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40987 if (!SWIG_IsOK(res1)) {
40988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40989 }
40990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40991 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40992 if (!SWIG_IsOK(ecode2)) {
40993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40994 }
40995 arg2 = static_cast< size_t >(val2);
40996 {
40997 arg3 = wxString_in_helper(obj2);
40998 if (arg3 == NULL) SWIG_fail;
40999 temp3 = true;
41000 }
41001 {
41002 PyThreadState* __tstate = wxPyBeginAllowThreads();
41003 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41004 wxPyEndAllowThreads(__tstate);
41005 if (PyErr_Occurred()) SWIG_fail;
41006 }
41007 resultobj = SWIG_Py_Void();
41008 {
41009 if (temp3)
41010 delete arg3;
41011 }
41012 return resultobj;
41013 fail:
41014 {
41015 if (temp3)
41016 delete arg3;
41017 }
41018 return NULL;
41019 }
41020
41021
41022 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41023 PyObject *resultobj = 0;
41024 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41025 size_t arg2 ;
41026 wxString result;
41027 void *argp1 = 0 ;
41028 int res1 = 0 ;
41029 size_t val2 ;
41030 int ecode2 = 0 ;
41031 PyObject * obj0 = 0 ;
41032 PyObject * obj1 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "pos", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41043 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41044 if (!SWIG_IsOK(ecode2)) {
41045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41046 }
41047 arg2 = static_cast< size_t >(val2);
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 {
41055 #if wxUSE_UNICODE
41056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41057 #else
41058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41059 #endif
41060 }
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj = 0;
41069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41070 wxString *arg2 = 0 ;
41071 wxString *arg3 = 0 ;
41072 int result;
41073 void *argp1 = 0 ;
41074 int res1 = 0 ;
41075 bool temp2 = false ;
41076 bool temp3 = false ;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 PyObject * obj2 = 0 ;
41080 char * kwnames[] = {
41081 (char *) "self",(char *) "menu",(char *) "item", NULL
41082 };
41083
41084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41086 if (!SWIG_IsOK(res1)) {
41087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41088 }
41089 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41090 {
41091 arg2 = wxString_in_helper(obj1);
41092 if (arg2 == NULL) SWIG_fail;
41093 temp2 = true;
41094 }
41095 {
41096 arg3 = wxString_in_helper(obj2);
41097 if (arg3 == NULL) SWIG_fail;
41098 temp3 = true;
41099 }
41100 {
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41103 wxPyEndAllowThreads(__tstate);
41104 if (PyErr_Occurred()) SWIG_fail;
41105 }
41106 resultobj = SWIG_From_int(static_cast< int >(result));
41107 {
41108 if (temp2)
41109 delete arg2;
41110 }
41111 {
41112 if (temp3)
41113 delete arg3;
41114 }
41115 return resultobj;
41116 fail:
41117 {
41118 if (temp2)
41119 delete arg2;
41120 }
41121 {
41122 if (temp3)
41123 delete arg3;
41124 }
41125 return NULL;
41126 }
41127
41128
41129 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41130 PyObject *resultobj = 0;
41131 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41132 int arg2 ;
41133 wxMenuItem *result = 0 ;
41134 void *argp1 = 0 ;
41135 int res1 = 0 ;
41136 int val2 ;
41137 int ecode2 = 0 ;
41138 PyObject * obj0 = 0 ;
41139 PyObject * obj1 = 0 ;
41140 char * kwnames[] = {
41141 (char *) "self",(char *) "id", NULL
41142 };
41143
41144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41146 if (!SWIG_IsOK(res1)) {
41147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41148 }
41149 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41150 ecode2 = SWIG_AsVal_int(obj1, &val2);
41151 if (!SWIG_IsOK(ecode2)) {
41152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41153 }
41154 arg2 = static_cast< int >(val2);
41155 {
41156 PyThreadState* __tstate = wxPyBeginAllowThreads();
41157 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41158 wxPyEndAllowThreads(__tstate);
41159 if (PyErr_Occurred()) SWIG_fail;
41160 }
41161 {
41162 resultobj = wxPyMake_wxObject(result, (bool)0);
41163 }
41164 return resultobj;
41165 fail:
41166 return NULL;
41167 }
41168
41169
41170 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41171 PyObject *resultobj = 0;
41172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41173 wxString *arg2 = 0 ;
41174 int result;
41175 void *argp1 = 0 ;
41176 int res1 = 0 ;
41177 bool temp2 = false ;
41178 PyObject * obj0 = 0 ;
41179 PyObject * obj1 = 0 ;
41180 char * kwnames[] = {
41181 (char *) "self",(char *) "title", NULL
41182 };
41183
41184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41186 if (!SWIG_IsOK(res1)) {
41187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41188 }
41189 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41190 {
41191 arg2 = wxString_in_helper(obj1);
41192 if (arg2 == NULL) SWIG_fail;
41193 temp2 = true;
41194 }
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 resultobj = SWIG_From_int(static_cast< int >(result));
41202 {
41203 if (temp2)
41204 delete arg2;
41205 }
41206 return resultobj;
41207 fail:
41208 {
41209 if (temp2)
41210 delete arg2;
41211 }
41212 return NULL;
41213 }
41214
41215
41216 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41217 PyObject *resultobj = 0;
41218 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41219 int arg2 ;
41220 bool arg3 ;
41221 void *argp1 = 0 ;
41222 int res1 = 0 ;
41223 int val2 ;
41224 int ecode2 = 0 ;
41225 bool val3 ;
41226 int ecode3 = 0 ;
41227 PyObject * obj0 = 0 ;
41228 PyObject * obj1 = 0 ;
41229 PyObject * obj2 = 0 ;
41230 char * kwnames[] = {
41231 (char *) "self",(char *) "id",(char *) "enable", NULL
41232 };
41233
41234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41236 if (!SWIG_IsOK(res1)) {
41237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41238 }
41239 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41240 ecode2 = SWIG_AsVal_int(obj1, &val2);
41241 if (!SWIG_IsOK(ecode2)) {
41242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41243 }
41244 arg2 = static_cast< int >(val2);
41245 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41246 if (!SWIG_IsOK(ecode3)) {
41247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41248 }
41249 arg3 = static_cast< bool >(val3);
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 (arg1)->Enable(arg2,arg3);
41253 wxPyEndAllowThreads(__tstate);
41254 if (PyErr_Occurred()) SWIG_fail;
41255 }
41256 resultobj = SWIG_Py_Void();
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj = 0;
41265 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41266 int arg2 ;
41267 bool arg3 ;
41268 void *argp1 = 0 ;
41269 int res1 = 0 ;
41270 int val2 ;
41271 int ecode2 = 0 ;
41272 bool val3 ;
41273 int ecode3 = 0 ;
41274 PyObject * obj0 = 0 ;
41275 PyObject * obj1 = 0 ;
41276 PyObject * obj2 = 0 ;
41277 char * kwnames[] = {
41278 (char *) "self",(char *) "id",(char *) "check", NULL
41279 };
41280
41281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41283 if (!SWIG_IsOK(res1)) {
41284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41285 }
41286 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41287 ecode2 = SWIG_AsVal_int(obj1, &val2);
41288 if (!SWIG_IsOK(ecode2)) {
41289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41290 }
41291 arg2 = static_cast< int >(val2);
41292 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41293 if (!SWIG_IsOK(ecode3)) {
41294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41295 }
41296 arg3 = static_cast< bool >(val3);
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 (arg1)->Check(arg2,arg3);
41300 wxPyEndAllowThreads(__tstate);
41301 if (PyErr_Occurred()) SWIG_fail;
41302 }
41303 resultobj = SWIG_Py_Void();
41304 return resultobj;
41305 fail:
41306 return NULL;
41307 }
41308
41309
41310 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41311 PyObject *resultobj = 0;
41312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41313 int arg2 ;
41314 bool result;
41315 void *argp1 = 0 ;
41316 int res1 = 0 ;
41317 int val2 ;
41318 int ecode2 = 0 ;
41319 PyObject * obj0 = 0 ;
41320 PyObject * obj1 = 0 ;
41321 char * kwnames[] = {
41322 (char *) "self",(char *) "id", NULL
41323 };
41324
41325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41327 if (!SWIG_IsOK(res1)) {
41328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41329 }
41330 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41331 ecode2 = SWIG_AsVal_int(obj1, &val2);
41332 if (!SWIG_IsOK(ecode2)) {
41333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41334 }
41335 arg2 = static_cast< int >(val2);
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41339 wxPyEndAllowThreads(__tstate);
41340 if (PyErr_Occurred()) SWIG_fail;
41341 }
41342 {
41343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41344 }
41345 return resultobj;
41346 fail:
41347 return NULL;
41348 }
41349
41350
41351 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41352 PyObject *resultobj = 0;
41353 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41354 int arg2 ;
41355 bool result;
41356 void *argp1 = 0 ;
41357 int res1 = 0 ;
41358 int val2 ;
41359 int ecode2 = 0 ;
41360 PyObject * obj0 = 0 ;
41361 PyObject * obj1 = 0 ;
41362 char * kwnames[] = {
41363 (char *) "self",(char *) "id", NULL
41364 };
41365
41366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41368 if (!SWIG_IsOK(res1)) {
41369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41370 }
41371 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41372 ecode2 = SWIG_AsVal_int(obj1, &val2);
41373 if (!SWIG_IsOK(ecode2)) {
41374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41375 }
41376 arg2 = static_cast< int >(val2);
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 {
41384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41385 }
41386 return resultobj;
41387 fail:
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41395 int arg2 ;
41396 wxString *arg3 = 0 ;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 int val2 ;
41400 int ecode2 = 0 ;
41401 bool temp3 = false ;
41402 PyObject * obj0 = 0 ;
41403 PyObject * obj1 = 0 ;
41404 PyObject * obj2 = 0 ;
41405 char * kwnames[] = {
41406 (char *) "self",(char *) "id",(char *) "label", NULL
41407 };
41408
41409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41411 if (!SWIG_IsOK(res1)) {
41412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41413 }
41414 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41415 ecode2 = SWIG_AsVal_int(obj1, &val2);
41416 if (!SWIG_IsOK(ecode2)) {
41417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41418 }
41419 arg2 = static_cast< int >(val2);
41420 {
41421 arg3 = wxString_in_helper(obj2);
41422 if (arg3 == NULL) SWIG_fail;
41423 temp3 = true;
41424 }
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41428 wxPyEndAllowThreads(__tstate);
41429 if (PyErr_Occurred()) SWIG_fail;
41430 }
41431 resultobj = SWIG_Py_Void();
41432 {
41433 if (temp3)
41434 delete arg3;
41435 }
41436 return resultobj;
41437 fail:
41438 {
41439 if (temp3)
41440 delete arg3;
41441 }
41442 return NULL;
41443 }
41444
41445
41446 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41447 PyObject *resultobj = 0;
41448 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41449 int arg2 ;
41450 wxString result;
41451 void *argp1 = 0 ;
41452 int res1 = 0 ;
41453 int val2 ;
41454 int ecode2 = 0 ;
41455 PyObject * obj0 = 0 ;
41456 PyObject * obj1 = 0 ;
41457 char * kwnames[] = {
41458 (char *) "self",(char *) "id", NULL
41459 };
41460
41461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41463 if (!SWIG_IsOK(res1)) {
41464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41465 }
41466 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41467 ecode2 = SWIG_AsVal_int(obj1, &val2);
41468 if (!SWIG_IsOK(ecode2)) {
41469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41470 }
41471 arg2 = static_cast< int >(val2);
41472 {
41473 PyThreadState* __tstate = wxPyBeginAllowThreads();
41474 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41475 wxPyEndAllowThreads(__tstate);
41476 if (PyErr_Occurred()) SWIG_fail;
41477 }
41478 {
41479 #if wxUSE_UNICODE
41480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41481 #else
41482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41483 #endif
41484 }
41485 return resultobj;
41486 fail:
41487 return NULL;
41488 }
41489
41490
41491 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41492 PyObject *resultobj = 0;
41493 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41494 int arg2 ;
41495 wxString *arg3 = 0 ;
41496 void *argp1 = 0 ;
41497 int res1 = 0 ;
41498 int val2 ;
41499 int ecode2 = 0 ;
41500 bool temp3 = false ;
41501 PyObject * obj0 = 0 ;
41502 PyObject * obj1 = 0 ;
41503 PyObject * obj2 = 0 ;
41504 char * kwnames[] = {
41505 (char *) "self",(char *) "id",(char *) "helpString", NULL
41506 };
41507
41508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41510 if (!SWIG_IsOK(res1)) {
41511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41512 }
41513 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41514 ecode2 = SWIG_AsVal_int(obj1, &val2);
41515 if (!SWIG_IsOK(ecode2)) {
41516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41517 }
41518 arg2 = static_cast< int >(val2);
41519 {
41520 arg3 = wxString_in_helper(obj2);
41521 if (arg3 == NULL) SWIG_fail;
41522 temp3 = true;
41523 }
41524 {
41525 PyThreadState* __tstate = wxPyBeginAllowThreads();
41526 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41527 wxPyEndAllowThreads(__tstate);
41528 if (PyErr_Occurred()) SWIG_fail;
41529 }
41530 resultobj = SWIG_Py_Void();
41531 {
41532 if (temp3)
41533 delete arg3;
41534 }
41535 return resultobj;
41536 fail:
41537 {
41538 if (temp3)
41539 delete arg3;
41540 }
41541 return NULL;
41542 }
41543
41544
41545 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41546 PyObject *resultobj = 0;
41547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41548 int arg2 ;
41549 wxString result;
41550 void *argp1 = 0 ;
41551 int res1 = 0 ;
41552 int val2 ;
41553 int ecode2 = 0 ;
41554 PyObject * obj0 = 0 ;
41555 PyObject * obj1 = 0 ;
41556 char * kwnames[] = {
41557 (char *) "self",(char *) "id", NULL
41558 };
41559
41560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41562 if (!SWIG_IsOK(res1)) {
41563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41564 }
41565 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41566 ecode2 = SWIG_AsVal_int(obj1, &val2);
41567 if (!SWIG_IsOK(ecode2)) {
41568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41569 }
41570 arg2 = static_cast< int >(val2);
41571 {
41572 PyThreadState* __tstate = wxPyBeginAllowThreads();
41573 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41574 wxPyEndAllowThreads(__tstate);
41575 if (PyErr_Occurred()) SWIG_fail;
41576 }
41577 {
41578 #if wxUSE_UNICODE
41579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41580 #else
41581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41582 #endif
41583 }
41584 return resultobj;
41585 fail:
41586 return NULL;
41587 }
41588
41589
41590 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41591 PyObject *resultobj = 0;
41592 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41593 wxFrame *result = 0 ;
41594 void *argp1 = 0 ;
41595 int res1 = 0 ;
41596 PyObject *swig_obj[1] ;
41597
41598 if (!args) SWIG_fail;
41599 swig_obj[0] = args;
41600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41601 if (!SWIG_IsOK(res1)) {
41602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41603 }
41604 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41605 {
41606 PyThreadState* __tstate = wxPyBeginAllowThreads();
41607 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41608 wxPyEndAllowThreads(__tstate);
41609 if (PyErr_Occurred()) SWIG_fail;
41610 }
41611 {
41612 resultobj = wxPyMake_wxObject(result, (bool)0);
41613 }
41614 return resultobj;
41615 fail:
41616 return NULL;
41617 }
41618
41619
41620 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41621 PyObject *resultobj = 0;
41622 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41623 bool result;
41624 void *argp1 = 0 ;
41625 int res1 = 0 ;
41626 PyObject *swig_obj[1] ;
41627
41628 if (!args) SWIG_fail;
41629 swig_obj[0] = args;
41630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41631 if (!SWIG_IsOK(res1)) {
41632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41633 }
41634 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41635 {
41636 PyThreadState* __tstate = wxPyBeginAllowThreads();
41637 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41638 wxPyEndAllowThreads(__tstate);
41639 if (PyErr_Occurred()) SWIG_fail;
41640 }
41641 {
41642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41643 }
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41651 PyObject *resultobj = 0;
41652 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41653 wxFrame *arg2 = (wxFrame *) 0 ;
41654 void *argp1 = 0 ;
41655 int res1 = 0 ;
41656 void *argp2 = 0 ;
41657 int res2 = 0 ;
41658 PyObject * obj0 = 0 ;
41659 PyObject * obj1 = 0 ;
41660 char * kwnames[] = {
41661 (char *) "self",(char *) "frame", NULL
41662 };
41663
41664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41666 if (!SWIG_IsOK(res1)) {
41667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41668 }
41669 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41671 if (!SWIG_IsOK(res2)) {
41672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41673 }
41674 arg2 = reinterpret_cast< wxFrame * >(argp2);
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 (arg1)->Attach(arg2);
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 resultobj = SWIG_Py_Void();
41682 return resultobj;
41683 fail:
41684 return NULL;
41685 }
41686
41687
41688 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41689 PyObject *resultobj = 0;
41690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41691 void *argp1 = 0 ;
41692 int res1 = 0 ;
41693 PyObject *swig_obj[1] ;
41694
41695 if (!args) SWIG_fail;
41696 swig_obj[0] = args;
41697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41698 if (!SWIG_IsOK(res1)) {
41699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41700 }
41701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41702 {
41703 PyThreadState* __tstate = wxPyBeginAllowThreads();
41704 (arg1)->Detach();
41705 wxPyEndAllowThreads(__tstate);
41706 if (PyErr_Occurred()) SWIG_fail;
41707 }
41708 resultobj = SWIG_Py_Void();
41709 return resultobj;
41710 fail:
41711 return NULL;
41712 }
41713
41714
41715 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41716 PyObject *resultobj = 0;
41717 bool arg1 ;
41718 bool val1 ;
41719 int ecode1 = 0 ;
41720 PyObject * obj0 = 0 ;
41721 char * kwnames[] = {
41722 (char *) "enable", NULL
41723 };
41724
41725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41726 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41727 if (!SWIG_IsOK(ecode1)) {
41728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41729 }
41730 arg1 = static_cast< bool >(val1);
41731 {
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 wxMenuBar::SetAutoWindowMenu(arg1);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_Py_Void();
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41745 PyObject *resultobj = 0;
41746 bool result;
41747
41748 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = (bool)wxMenuBar::GetAutoWindowMenu();
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41757 }
41758 return resultobj;
41759 fail:
41760 return NULL;
41761 }
41762
41763
41764 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41765 PyObject *obj;
41766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41767 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41768 return SWIG_Py_Void();
41769 }
41770
41771 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41772 return SWIG_Python_InitShadowInstance(args);
41773 }
41774
41775 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41776 PyObject *resultobj = 0;
41777 wxMenu *arg1 = (wxMenu *) NULL ;
41778 int arg2 = (int) wxID_ANY ;
41779 wxString const &arg3_defvalue = wxPyEmptyString ;
41780 wxString *arg3 = (wxString *) &arg3_defvalue ;
41781 wxString const &arg4_defvalue = wxPyEmptyString ;
41782 wxString *arg4 = (wxString *) &arg4_defvalue ;
41783 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41784 wxMenu *arg6 = (wxMenu *) NULL ;
41785 wxMenuItem *result = 0 ;
41786 void *argp1 = 0 ;
41787 int res1 = 0 ;
41788 int val2 ;
41789 int ecode2 = 0 ;
41790 bool temp3 = false ;
41791 bool temp4 = false ;
41792 int val5 ;
41793 int ecode5 = 0 ;
41794 void *argp6 = 0 ;
41795 int res6 = 0 ;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 PyObject * obj2 = 0 ;
41799 PyObject * obj3 = 0 ;
41800 PyObject * obj4 = 0 ;
41801 PyObject * obj5 = 0 ;
41802 char * kwnames[] = {
41803 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41804 };
41805
41806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41807 if (obj0) {
41808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41809 if (!SWIG_IsOK(res1)) {
41810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41811 }
41812 arg1 = reinterpret_cast< wxMenu * >(argp1);
41813 }
41814 if (obj1) {
41815 ecode2 = SWIG_AsVal_int(obj1, &val2);
41816 if (!SWIG_IsOK(ecode2)) {
41817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41818 }
41819 arg2 = static_cast< int >(val2);
41820 }
41821 if (obj2) {
41822 {
41823 arg3 = wxString_in_helper(obj2);
41824 if (arg3 == NULL) SWIG_fail;
41825 temp3 = true;
41826 }
41827 }
41828 if (obj3) {
41829 {
41830 arg4 = wxString_in_helper(obj3);
41831 if (arg4 == NULL) SWIG_fail;
41832 temp4 = true;
41833 }
41834 }
41835 if (obj4) {
41836 ecode5 = SWIG_AsVal_int(obj4, &val5);
41837 if (!SWIG_IsOK(ecode5)) {
41838 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41839 }
41840 arg5 = static_cast< wxItemKind >(val5);
41841 }
41842 if (obj5) {
41843 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41844 if (!SWIG_IsOK(res6)) {
41845 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41846 }
41847 arg6 = reinterpret_cast< wxMenu * >(argp6);
41848 }
41849 {
41850 PyThreadState* __tstate = wxPyBeginAllowThreads();
41851 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41852 wxPyEndAllowThreads(__tstate);
41853 if (PyErr_Occurred()) SWIG_fail;
41854 }
41855 {
41856 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41857 }
41858 {
41859 if (temp3)
41860 delete arg3;
41861 }
41862 {
41863 if (temp4)
41864 delete arg4;
41865 }
41866 return resultobj;
41867 fail:
41868 {
41869 if (temp3)
41870 delete arg3;
41871 }
41872 {
41873 if (temp4)
41874 delete arg4;
41875 }
41876 return NULL;
41877 }
41878
41879
41880 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41881 PyObject *resultobj = 0;
41882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41883 void *argp1 = 0 ;
41884 int res1 = 0 ;
41885 PyObject *swig_obj[1] ;
41886
41887 if (!args) SWIG_fail;
41888 swig_obj[0] = args;
41889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41890 if (!SWIG_IsOK(res1)) {
41891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41892 }
41893 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41894 {
41895 PyThreadState* __tstate = wxPyBeginAllowThreads();
41896 delete arg1;
41897
41898 wxPyEndAllowThreads(__tstate);
41899 if (PyErr_Occurred()) SWIG_fail;
41900 }
41901 resultobj = SWIG_Py_Void();
41902 return resultobj;
41903 fail:
41904 return NULL;
41905 }
41906
41907
41908 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41909 PyObject *resultobj = 0;
41910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41911 wxMenu *result = 0 ;
41912 void *argp1 = 0 ;
41913 int res1 = 0 ;
41914 PyObject *swig_obj[1] ;
41915
41916 if (!args) SWIG_fail;
41917 swig_obj[0] = args;
41918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41919 if (!SWIG_IsOK(res1)) {
41920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41921 }
41922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41923 {
41924 PyThreadState* __tstate = wxPyBeginAllowThreads();
41925 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 {
41930 resultobj = wxPyMake_wxObject(result, 0);
41931 }
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj = 0;
41940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41941 wxMenu *arg2 = (wxMenu *) 0 ;
41942 void *argp1 = 0 ;
41943 int res1 = 0 ;
41944 void *argp2 = 0 ;
41945 int res2 = 0 ;
41946 PyObject * obj0 = 0 ;
41947 PyObject * obj1 = 0 ;
41948 char * kwnames[] = {
41949 (char *) "self",(char *) "menu", NULL
41950 };
41951
41952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41954 if (!SWIG_IsOK(res1)) {
41955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41956 }
41957 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41959 if (!SWIG_IsOK(res2)) {
41960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41961 }
41962 arg2 = reinterpret_cast< wxMenu * >(argp2);
41963 {
41964 PyThreadState* __tstate = wxPyBeginAllowThreads();
41965 (arg1)->SetMenu(arg2);
41966 wxPyEndAllowThreads(__tstate);
41967 if (PyErr_Occurred()) SWIG_fail;
41968 }
41969 resultobj = SWIG_Py_Void();
41970 return resultobj;
41971 fail:
41972 return NULL;
41973 }
41974
41975
41976 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41977 PyObject *resultobj = 0;
41978 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41979 int arg2 ;
41980 void *argp1 = 0 ;
41981 int res1 = 0 ;
41982 int val2 ;
41983 int ecode2 = 0 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 char * kwnames[] = {
41987 (char *) "self",(char *) "id", NULL
41988 };
41989
41990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
41991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41992 if (!SWIG_IsOK(res1)) {
41993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41994 }
41995 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41996 ecode2 = SWIG_AsVal_int(obj1, &val2);
41997 if (!SWIG_IsOK(ecode2)) {
41998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
41999 }
42000 arg2 = static_cast< int >(val2);
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 (arg1)->SetId(arg2);
42004 wxPyEndAllowThreads(__tstate);
42005 if (PyErr_Occurred()) SWIG_fail;
42006 }
42007 resultobj = SWIG_Py_Void();
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42015 PyObject *resultobj = 0;
42016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42017 int result;
42018 void *argp1 = 0 ;
42019 int res1 = 0 ;
42020 PyObject *swig_obj[1] ;
42021
42022 if (!args) SWIG_fail;
42023 swig_obj[0] = args;
42024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (int)((wxMenuItem const *)arg1)->GetId();
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 resultobj = SWIG_From_int(static_cast< int >(result));
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42043 PyObject *resultobj = 0;
42044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42045 bool result;
42046 void *argp1 = 0 ;
42047 int res1 = 0 ;
42048 PyObject *swig_obj[1] ;
42049
42050 if (!args) SWIG_fail;
42051 swig_obj[0] = args;
42052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42053 if (!SWIG_IsOK(res1)) {
42054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42057 {
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 {
42064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42065 }
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42073 PyObject *resultobj = 0;
42074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42075 wxString *arg2 = 0 ;
42076 void *argp1 = 0 ;
42077 int res1 = 0 ;
42078 bool temp2 = false ;
42079 PyObject * obj0 = 0 ;
42080 PyObject * obj1 = 0 ;
42081 char * kwnames[] = {
42082 (char *) "self",(char *) "str", NULL
42083 };
42084
42085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42087 if (!SWIG_IsOK(res1)) {
42088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42089 }
42090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42091 {
42092 arg2 = wxString_in_helper(obj1);
42093 if (arg2 == NULL) SWIG_fail;
42094 temp2 = true;
42095 }
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 (arg1)->SetText((wxString const &)*arg2);
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 resultobj = SWIG_Py_Void();
42103 {
42104 if (temp2)
42105 delete arg2;
42106 }
42107 return resultobj;
42108 fail:
42109 {
42110 if (temp2)
42111 delete arg2;
42112 }
42113 return NULL;
42114 }
42115
42116
42117 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42118 PyObject *resultobj = 0;
42119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42120 wxString result;
42121 void *argp1 = 0 ;
42122 int res1 = 0 ;
42123 PyObject *swig_obj[1] ;
42124
42125 if (!args) SWIG_fail;
42126 swig_obj[0] = args;
42127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42128 if (!SWIG_IsOK(res1)) {
42129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42130 }
42131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42132 {
42133 PyThreadState* __tstate = wxPyBeginAllowThreads();
42134 result = ((wxMenuItem const *)arg1)->GetLabel();
42135 wxPyEndAllowThreads(__tstate);
42136 if (PyErr_Occurred()) SWIG_fail;
42137 }
42138 {
42139 #if wxUSE_UNICODE
42140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42141 #else
42142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42143 #endif
42144 }
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42152 PyObject *resultobj = 0;
42153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42154 wxString *result = 0 ;
42155 void *argp1 = 0 ;
42156 int res1 = 0 ;
42157 PyObject *swig_obj[1] ;
42158
42159 if (!args) SWIG_fail;
42160 swig_obj[0] = args;
42161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42162 if (!SWIG_IsOK(res1)) {
42163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42164 }
42165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42166 {
42167 PyThreadState* __tstate = wxPyBeginAllowThreads();
42168 {
42169 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42170 result = (wxString *) &_result_ref;
42171 }
42172 wxPyEndAllowThreads(__tstate);
42173 if (PyErr_Occurred()) SWIG_fail;
42174 }
42175 {
42176 #if wxUSE_UNICODE
42177 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42178 #else
42179 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42180 #endif
42181 }
42182 return resultobj;
42183 fail:
42184 return NULL;
42185 }
42186
42187
42188 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42189 PyObject *resultobj = 0;
42190 wxString *arg1 = 0 ;
42191 wxString result;
42192 bool temp1 = false ;
42193 PyObject * obj0 = 0 ;
42194 char * kwnames[] = {
42195 (char *) "text", NULL
42196 };
42197
42198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42199 {
42200 arg1 = wxString_in_helper(obj0);
42201 if (arg1 == NULL) SWIG_fail;
42202 temp1 = true;
42203 }
42204 {
42205 PyThreadState* __tstate = wxPyBeginAllowThreads();
42206 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42207 wxPyEndAllowThreads(__tstate);
42208 if (PyErr_Occurred()) SWIG_fail;
42209 }
42210 {
42211 #if wxUSE_UNICODE
42212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42213 #else
42214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42215 #endif
42216 }
42217 {
42218 if (temp1)
42219 delete arg1;
42220 }
42221 return resultobj;
42222 fail:
42223 {
42224 if (temp1)
42225 delete arg1;
42226 }
42227 return NULL;
42228 }
42229
42230
42231 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42232 PyObject *resultobj = 0;
42233 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42234 wxItemKind result;
42235 void *argp1 = 0 ;
42236 int res1 = 0 ;
42237 PyObject *swig_obj[1] ;
42238
42239 if (!args) SWIG_fail;
42240 swig_obj[0] = args;
42241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42242 if (!SWIG_IsOK(res1)) {
42243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42244 }
42245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42246 {
42247 PyThreadState* __tstate = wxPyBeginAllowThreads();
42248 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42249 wxPyEndAllowThreads(__tstate);
42250 if (PyErr_Occurred()) SWIG_fail;
42251 }
42252 resultobj = SWIG_From_int(static_cast< int >(result));
42253 return resultobj;
42254 fail:
42255 return NULL;
42256 }
42257
42258
42259 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42260 PyObject *resultobj = 0;
42261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42262 wxItemKind arg2 ;
42263 void *argp1 = 0 ;
42264 int res1 = 0 ;
42265 int val2 ;
42266 int ecode2 = 0 ;
42267 PyObject * obj0 = 0 ;
42268 PyObject * obj1 = 0 ;
42269 char * kwnames[] = {
42270 (char *) "self",(char *) "kind", NULL
42271 };
42272
42273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42275 if (!SWIG_IsOK(res1)) {
42276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42277 }
42278 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42279 ecode2 = SWIG_AsVal_int(obj1, &val2);
42280 if (!SWIG_IsOK(ecode2)) {
42281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42282 }
42283 arg2 = static_cast< wxItemKind >(val2);
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 (arg1)->SetKind(arg2);
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 resultobj = SWIG_Py_Void();
42291 return resultobj;
42292 fail:
42293 return NULL;
42294 }
42295
42296
42297 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42298 PyObject *resultobj = 0;
42299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42300 bool arg2 ;
42301 void *argp1 = 0 ;
42302 int res1 = 0 ;
42303 bool val2 ;
42304 int ecode2 = 0 ;
42305 PyObject * obj0 = 0 ;
42306 PyObject * obj1 = 0 ;
42307 char * kwnames[] = {
42308 (char *) "self",(char *) "checkable", NULL
42309 };
42310
42311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42313 if (!SWIG_IsOK(res1)) {
42314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42315 }
42316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42318 if (!SWIG_IsOK(ecode2)) {
42319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42320 }
42321 arg2 = static_cast< bool >(val2);
42322 {
42323 PyThreadState* __tstate = wxPyBeginAllowThreads();
42324 (arg1)->SetCheckable(arg2);
42325 wxPyEndAllowThreads(__tstate);
42326 if (PyErr_Occurred()) SWIG_fail;
42327 }
42328 resultobj = SWIG_Py_Void();
42329 return resultobj;
42330 fail:
42331 return NULL;
42332 }
42333
42334
42335 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42336 PyObject *resultobj = 0;
42337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42338 bool result;
42339 void *argp1 = 0 ;
42340 int res1 = 0 ;
42341 PyObject *swig_obj[1] ;
42342
42343 if (!args) SWIG_fail;
42344 swig_obj[0] = args;
42345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42346 if (!SWIG_IsOK(res1)) {
42347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42348 }
42349 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42350 {
42351 PyThreadState* __tstate = wxPyBeginAllowThreads();
42352 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 {
42357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42358 }
42359 return resultobj;
42360 fail:
42361 return NULL;
42362 }
42363
42364
42365 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42366 PyObject *resultobj = 0;
42367 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42368 bool result;
42369 void *argp1 = 0 ;
42370 int res1 = 0 ;
42371 PyObject *swig_obj[1] ;
42372
42373 if (!args) SWIG_fail;
42374 swig_obj[0] = args;
42375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42376 if (!SWIG_IsOK(res1)) {
42377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42378 }
42379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42380 {
42381 PyThreadState* __tstate = wxPyBeginAllowThreads();
42382 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 {
42387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42388 }
42389 return resultobj;
42390 fail:
42391 return NULL;
42392 }
42393
42394
42395 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj = 0;
42397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42398 wxMenu *arg2 = (wxMenu *) 0 ;
42399 void *argp1 = 0 ;
42400 int res1 = 0 ;
42401 void *argp2 = 0 ;
42402 int res2 = 0 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 char * kwnames[] = {
42406 (char *) "self",(char *) "menu", NULL
42407 };
42408
42409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42416 if (!SWIG_IsOK(res2)) {
42417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42418 }
42419 arg2 = reinterpret_cast< wxMenu * >(argp2);
42420 {
42421 PyThreadState* __tstate = wxPyBeginAllowThreads();
42422 (arg1)->SetSubMenu(arg2);
42423 wxPyEndAllowThreads(__tstate);
42424 if (PyErr_Occurred()) SWIG_fail;
42425 }
42426 resultobj = SWIG_Py_Void();
42427 return resultobj;
42428 fail:
42429 return NULL;
42430 }
42431
42432
42433 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42434 PyObject *resultobj = 0;
42435 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42436 wxMenu *result = 0 ;
42437 void *argp1 = 0 ;
42438 int res1 = 0 ;
42439 PyObject *swig_obj[1] ;
42440
42441 if (!args) SWIG_fail;
42442 swig_obj[0] = args;
42443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42444 if (!SWIG_IsOK(res1)) {
42445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42446 }
42447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42448 {
42449 PyThreadState* __tstate = wxPyBeginAllowThreads();
42450 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42451 wxPyEndAllowThreads(__tstate);
42452 if (PyErr_Occurred()) SWIG_fail;
42453 }
42454 {
42455 resultobj = wxPyMake_wxObject(result, 0);
42456 }
42457 return resultobj;
42458 fail:
42459 return NULL;
42460 }
42461
42462
42463 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42464 PyObject *resultobj = 0;
42465 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42466 bool arg2 = (bool) true ;
42467 void *argp1 = 0 ;
42468 int res1 = 0 ;
42469 bool val2 ;
42470 int ecode2 = 0 ;
42471 PyObject * obj0 = 0 ;
42472 PyObject * obj1 = 0 ;
42473 char * kwnames[] = {
42474 (char *) "self",(char *) "enable", NULL
42475 };
42476
42477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42479 if (!SWIG_IsOK(res1)) {
42480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42481 }
42482 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42483 if (obj1) {
42484 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42485 if (!SWIG_IsOK(ecode2)) {
42486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42487 }
42488 arg2 = static_cast< bool >(val2);
42489 }
42490 {
42491 PyThreadState* __tstate = wxPyBeginAllowThreads();
42492 (arg1)->Enable(arg2);
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 resultobj = SWIG_Py_Void();
42497 return resultobj;
42498 fail:
42499 return NULL;
42500 }
42501
42502
42503 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42504 PyObject *resultobj = 0;
42505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42506 bool result;
42507 void *argp1 = 0 ;
42508 int res1 = 0 ;
42509 PyObject *swig_obj[1] ;
42510
42511 if (!args) SWIG_fail;
42512 swig_obj[0] = args;
42513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42514 if (!SWIG_IsOK(res1)) {
42515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42516 }
42517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 {
42525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42526 }
42527 return resultobj;
42528 fail:
42529 return NULL;
42530 }
42531
42532
42533 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42534 PyObject *resultobj = 0;
42535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42536 bool arg2 = (bool) true ;
42537 void *argp1 = 0 ;
42538 int res1 = 0 ;
42539 bool val2 ;
42540 int ecode2 = 0 ;
42541 PyObject * obj0 = 0 ;
42542 PyObject * obj1 = 0 ;
42543 char * kwnames[] = {
42544 (char *) "self",(char *) "check", NULL
42545 };
42546
42547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42549 if (!SWIG_IsOK(res1)) {
42550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42551 }
42552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42553 if (obj1) {
42554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42555 if (!SWIG_IsOK(ecode2)) {
42556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42557 }
42558 arg2 = static_cast< bool >(val2);
42559 }
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 (arg1)->Check(arg2);
42563 wxPyEndAllowThreads(__tstate);
42564 if (PyErr_Occurred()) SWIG_fail;
42565 }
42566 resultobj = SWIG_Py_Void();
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42574 PyObject *resultobj = 0;
42575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42576 bool result;
42577 void *argp1 = 0 ;
42578 int res1 = 0 ;
42579 PyObject *swig_obj[1] ;
42580
42581 if (!args) SWIG_fail;
42582 swig_obj[0] = args;
42583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42584 if (!SWIG_IsOK(res1)) {
42585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42586 }
42587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42591 wxPyEndAllowThreads(__tstate);
42592 if (PyErr_Occurred()) SWIG_fail;
42593 }
42594 {
42595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42596 }
42597 return resultobj;
42598 fail:
42599 return NULL;
42600 }
42601
42602
42603 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42604 PyObject *resultobj = 0;
42605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42606 void *argp1 = 0 ;
42607 int res1 = 0 ;
42608 PyObject *swig_obj[1] ;
42609
42610 if (!args) SWIG_fail;
42611 swig_obj[0] = args;
42612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42613 if (!SWIG_IsOK(res1)) {
42614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42615 }
42616 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 (arg1)->Toggle();
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 resultobj = SWIG_Py_Void();
42624 return resultobj;
42625 fail:
42626 return NULL;
42627 }
42628
42629
42630 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42631 PyObject *resultobj = 0;
42632 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42633 wxString *arg2 = 0 ;
42634 void *argp1 = 0 ;
42635 int res1 = 0 ;
42636 bool temp2 = false ;
42637 PyObject * obj0 = 0 ;
42638 PyObject * obj1 = 0 ;
42639 char * kwnames[] = {
42640 (char *) "self",(char *) "str", NULL
42641 };
42642
42643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42645 if (!SWIG_IsOK(res1)) {
42646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42647 }
42648 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42649 {
42650 arg2 = wxString_in_helper(obj1);
42651 if (arg2 == NULL) SWIG_fail;
42652 temp2 = true;
42653 }
42654 {
42655 PyThreadState* __tstate = wxPyBeginAllowThreads();
42656 (arg1)->SetHelp((wxString const &)*arg2);
42657 wxPyEndAllowThreads(__tstate);
42658 if (PyErr_Occurred()) SWIG_fail;
42659 }
42660 resultobj = SWIG_Py_Void();
42661 {
42662 if (temp2)
42663 delete arg2;
42664 }
42665 return resultobj;
42666 fail:
42667 {
42668 if (temp2)
42669 delete arg2;
42670 }
42671 return NULL;
42672 }
42673
42674
42675 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42676 PyObject *resultobj = 0;
42677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42678 wxString *result = 0 ;
42679 void *argp1 = 0 ;
42680 int res1 = 0 ;
42681 PyObject *swig_obj[1] ;
42682
42683 if (!args) SWIG_fail;
42684 swig_obj[0] = args;
42685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42686 if (!SWIG_IsOK(res1)) {
42687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42688 }
42689 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42690 {
42691 PyThreadState* __tstate = wxPyBeginAllowThreads();
42692 {
42693 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42694 result = (wxString *) &_result_ref;
42695 }
42696 wxPyEndAllowThreads(__tstate);
42697 if (PyErr_Occurred()) SWIG_fail;
42698 }
42699 {
42700 #if wxUSE_UNICODE
42701 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42702 #else
42703 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42704 #endif
42705 }
42706 return resultobj;
42707 fail:
42708 return NULL;
42709 }
42710
42711
42712 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42713 PyObject *resultobj = 0;
42714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42715 wxAcceleratorEntry *result = 0 ;
42716 void *argp1 = 0 ;
42717 int res1 = 0 ;
42718 PyObject *swig_obj[1] ;
42719
42720 if (!args) SWIG_fail;
42721 swig_obj[0] = args;
42722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42723 if (!SWIG_IsOK(res1)) {
42724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42725 }
42726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42727 {
42728 PyThreadState* __tstate = wxPyBeginAllowThreads();
42729 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42730 wxPyEndAllowThreads(__tstate);
42731 if (PyErr_Occurred()) SWIG_fail;
42732 }
42733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42734 return resultobj;
42735 fail:
42736 return NULL;
42737 }
42738
42739
42740 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42741 PyObject *resultobj = 0;
42742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42743 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42744 void *argp1 = 0 ;
42745 int res1 = 0 ;
42746 void *argp2 = 0 ;
42747 int res2 = 0 ;
42748 PyObject * obj0 = 0 ;
42749 PyObject * obj1 = 0 ;
42750 char * kwnames[] = {
42751 (char *) "self",(char *) "accel", NULL
42752 };
42753
42754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42756 if (!SWIG_IsOK(res1)) {
42757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42758 }
42759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42761 if (!SWIG_IsOK(res2)) {
42762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42763 }
42764 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 (arg1)->SetAccel(arg2);
42768 wxPyEndAllowThreads(__tstate);
42769 if (PyErr_Occurred()) SWIG_fail;
42770 }
42771 resultobj = SWIG_Py_Void();
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = 0;
42780 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42781 wxBitmap *arg2 = 0 ;
42782 void *argp1 = 0 ;
42783 int res1 = 0 ;
42784 void *argp2 = 0 ;
42785 int res2 = 0 ;
42786 PyObject * obj0 = 0 ;
42787 PyObject * obj1 = 0 ;
42788 char * kwnames[] = {
42789 (char *) "self",(char *) "bitmap", NULL
42790 };
42791
42792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42794 if (!SWIG_IsOK(res1)) {
42795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42796 }
42797 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42798 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42799 if (!SWIG_IsOK(res2)) {
42800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42801 }
42802 if (!argp2) {
42803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42804 }
42805 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 resultobj = SWIG_Py_Void();
42813 return resultobj;
42814 fail:
42815 return NULL;
42816 }
42817
42818
42819 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42820 PyObject *resultobj = 0;
42821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42822 wxBitmap *result = 0 ;
42823 void *argp1 = 0 ;
42824 int res1 = 0 ;
42825 PyObject *swig_obj[1] ;
42826
42827 if (!args) SWIG_fail;
42828 swig_obj[0] = args;
42829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42830 if (!SWIG_IsOK(res1)) {
42831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42832 }
42833 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42834 {
42835 PyThreadState* __tstate = wxPyBeginAllowThreads();
42836 {
42837 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42838 result = (wxBitmap *) &_result_ref;
42839 }
42840 wxPyEndAllowThreads(__tstate);
42841 if (PyErr_Occurred()) SWIG_fail;
42842 }
42843 {
42844 wxBitmap* resultptr = new wxBitmap(*result);
42845 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42854 PyObject *resultobj = 0;
42855 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42856 wxFont *arg2 = 0 ;
42857 void *argp1 = 0 ;
42858 int res1 = 0 ;
42859 void *argp2 = 0 ;
42860 int res2 = 0 ;
42861 PyObject * obj0 = 0 ;
42862 PyObject * obj1 = 0 ;
42863 char * kwnames[] = {
42864 (char *) "self",(char *) "font", NULL
42865 };
42866
42867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42869 if (!SWIG_IsOK(res1)) {
42870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42871 }
42872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42874 if (!SWIG_IsOK(res2)) {
42875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42876 }
42877 if (!argp2) {
42878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42879 }
42880 arg2 = reinterpret_cast< wxFont * >(argp2);
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 resultobj = SWIG_Py_Void();
42888 return resultobj;
42889 fail:
42890 return NULL;
42891 }
42892
42893
42894 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42895 PyObject *resultobj = 0;
42896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42897 wxFont result;
42898 void *argp1 = 0 ;
42899 int res1 = 0 ;
42900 PyObject *swig_obj[1] ;
42901
42902 if (!args) SWIG_fail;
42903 swig_obj[0] = args;
42904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42905 if (!SWIG_IsOK(res1)) {
42906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42907 }
42908 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 result = wxMenuItem_GetFont(arg1);
42912 wxPyEndAllowThreads(__tstate);
42913 if (PyErr_Occurred()) SWIG_fail;
42914 }
42915 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42916 return resultobj;
42917 fail:
42918 return NULL;
42919 }
42920
42921
42922 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42923 PyObject *resultobj = 0;
42924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42925 wxColour *arg2 = 0 ;
42926 void *argp1 = 0 ;
42927 int res1 = 0 ;
42928 wxColour temp2 ;
42929 PyObject * obj0 = 0 ;
42930 PyObject * obj1 = 0 ;
42931 char * kwnames[] = {
42932 (char *) "self",(char *) "colText", NULL
42933 };
42934
42935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42937 if (!SWIG_IsOK(res1)) {
42938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42939 }
42940 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42941 {
42942 arg2 = &temp2;
42943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42944 }
42945 {
42946 PyThreadState* __tstate = wxPyBeginAllowThreads();
42947 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42948 wxPyEndAllowThreads(__tstate);
42949 if (PyErr_Occurred()) SWIG_fail;
42950 }
42951 resultobj = SWIG_Py_Void();
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42959 PyObject *resultobj = 0;
42960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42961 wxColour result;
42962 void *argp1 = 0 ;
42963 int res1 = 0 ;
42964 PyObject *swig_obj[1] ;
42965
42966 if (!args) SWIG_fail;
42967 swig_obj[0] = args;
42968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42969 if (!SWIG_IsOK(res1)) {
42970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42971 }
42972 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 result = wxMenuItem_GetTextColour(arg1);
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42980 return resultobj;
42981 fail:
42982 return NULL;
42983 }
42984
42985
42986 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42987 PyObject *resultobj = 0;
42988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42989 wxColour *arg2 = 0 ;
42990 void *argp1 = 0 ;
42991 int res1 = 0 ;
42992 wxColour temp2 ;
42993 PyObject * obj0 = 0 ;
42994 PyObject * obj1 = 0 ;
42995 char * kwnames[] = {
42996 (char *) "self",(char *) "colBack", NULL
42997 };
42998
42999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43001 if (!SWIG_IsOK(res1)) {
43002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43003 }
43004 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43005 {
43006 arg2 = &temp2;
43007 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43008 }
43009 {
43010 PyThreadState* __tstate = wxPyBeginAllowThreads();
43011 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 resultobj = SWIG_Py_Void();
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43023 PyObject *resultobj = 0;
43024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43025 wxColour result;
43026 void *argp1 = 0 ;
43027 int res1 = 0 ;
43028 PyObject *swig_obj[1] ;
43029
43030 if (!args) SWIG_fail;
43031 swig_obj[0] = args;
43032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43033 if (!SWIG_IsOK(res1)) {
43034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43035 }
43036 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43037 {
43038 PyThreadState* __tstate = wxPyBeginAllowThreads();
43039 result = wxMenuItem_GetBackgroundColour(arg1);
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43051 PyObject *resultobj = 0;
43052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43053 wxBitmap *arg2 = 0 ;
43054 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43055 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43056 void *argp1 = 0 ;
43057 int res1 = 0 ;
43058 void *argp2 = 0 ;
43059 int res2 = 0 ;
43060 void *argp3 = 0 ;
43061 int res3 = 0 ;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064 PyObject * obj2 = 0 ;
43065 char * kwnames[] = {
43066 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43067 };
43068
43069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43071 if (!SWIG_IsOK(res1)) {
43072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43073 }
43074 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43075 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43076 if (!SWIG_IsOK(res2)) {
43077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43078 }
43079 if (!argp2) {
43080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43081 }
43082 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43083 if (obj2) {
43084 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43085 if (!SWIG_IsOK(res3)) {
43086 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43087 }
43088 if (!argp3) {
43089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43090 }
43091 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43092 }
43093 {
43094 PyThreadState* __tstate = wxPyBeginAllowThreads();
43095 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43096 wxPyEndAllowThreads(__tstate);
43097 if (PyErr_Occurred()) SWIG_fail;
43098 }
43099 resultobj = SWIG_Py_Void();
43100 return resultobj;
43101 fail:
43102 return NULL;
43103 }
43104
43105
43106 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43107 PyObject *resultobj = 0;
43108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43109 wxBitmap *arg2 = 0 ;
43110 void *argp1 = 0 ;
43111 int res1 = 0 ;
43112 void *argp2 = 0 ;
43113 int res2 = 0 ;
43114 PyObject * obj0 = 0 ;
43115 PyObject * obj1 = 0 ;
43116 char * kwnames[] = {
43117 (char *) "self",(char *) "bmpDisabled", NULL
43118 };
43119
43120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43126 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43127 if (!SWIG_IsOK(res2)) {
43128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43129 }
43130 if (!argp2) {
43131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43132 }
43133 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43134 {
43135 PyThreadState* __tstate = wxPyBeginAllowThreads();
43136 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 resultobj = SWIG_Py_Void();
43141 return resultobj;
43142 fail:
43143 return NULL;
43144 }
43145
43146
43147 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43148 PyObject *resultobj = 0;
43149 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43150 wxBitmap *result = 0 ;
43151 void *argp1 = 0 ;
43152 int res1 = 0 ;
43153 PyObject *swig_obj[1] ;
43154
43155 if (!args) SWIG_fail;
43156 swig_obj[0] = args;
43157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43158 if (!SWIG_IsOK(res1)) {
43159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43160 }
43161 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43162 {
43163 PyThreadState* __tstate = wxPyBeginAllowThreads();
43164 {
43165 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43166 result = (wxBitmap *) &_result_ref;
43167 }
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 wxBitmap* resultptr = new wxBitmap(*result);
43173 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43182 PyObject *resultobj = 0;
43183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43184 int arg2 ;
43185 void *argp1 = 0 ;
43186 int res1 = 0 ;
43187 int val2 ;
43188 int ecode2 = 0 ;
43189 PyObject * obj0 = 0 ;
43190 PyObject * obj1 = 0 ;
43191 char * kwnames[] = {
43192 (char *) "self",(char *) "nWidth", NULL
43193 };
43194
43195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43197 if (!SWIG_IsOK(res1)) {
43198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43199 }
43200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43201 ecode2 = SWIG_AsVal_int(obj1, &val2);
43202 if (!SWIG_IsOK(ecode2)) {
43203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43204 }
43205 arg2 = static_cast< int >(val2);
43206 {
43207 PyThreadState* __tstate = wxPyBeginAllowThreads();
43208 wxMenuItem_SetMarginWidth(arg1,arg2);
43209 wxPyEndAllowThreads(__tstate);
43210 if (PyErr_Occurred()) SWIG_fail;
43211 }
43212 resultobj = SWIG_Py_Void();
43213 return resultobj;
43214 fail:
43215 return NULL;
43216 }
43217
43218
43219 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43220 PyObject *resultobj = 0;
43221 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43222 int result;
43223 void *argp1 = 0 ;
43224 int res1 = 0 ;
43225 PyObject *swig_obj[1] ;
43226
43227 if (!args) SWIG_fail;
43228 swig_obj[0] = args;
43229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43230 if (!SWIG_IsOK(res1)) {
43231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43232 }
43233 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 result = (int)wxMenuItem_GetMarginWidth(arg1);
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 resultobj = SWIG_From_int(static_cast< int >(result));
43241 return resultobj;
43242 fail:
43243 return NULL;
43244 }
43245
43246
43247 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43248 PyObject *resultobj = 0;
43249 int result;
43250
43251 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 result = (int)wxMenuItem_GetDefaultMarginWidth();
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 resultobj = SWIG_From_int(static_cast< int >(result));
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43266 PyObject *resultobj = 0;
43267 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43268 bool result;
43269 void *argp1 = 0 ;
43270 int res1 = 0 ;
43271 PyObject *swig_obj[1] ;
43272
43273 if (!args) SWIG_fail;
43274 swig_obj[0] = args;
43275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43283 wxPyEndAllowThreads(__tstate);
43284 if (PyErr_Occurred()) SWIG_fail;
43285 }
43286 {
43287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43288 }
43289 return resultobj;
43290 fail:
43291 return NULL;
43292 }
43293
43294
43295 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43296 PyObject *resultobj = 0;
43297 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43298 bool arg2 = (bool) true ;
43299 void *argp1 = 0 ;
43300 int res1 = 0 ;
43301 bool val2 ;
43302 int ecode2 = 0 ;
43303 PyObject * obj0 = 0 ;
43304 PyObject * obj1 = 0 ;
43305 char * kwnames[] = {
43306 (char *) "self",(char *) "ownerDrawn", NULL
43307 };
43308
43309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43311 if (!SWIG_IsOK(res1)) {
43312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43313 }
43314 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43315 if (obj1) {
43316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43317 if (!SWIG_IsOK(ecode2)) {
43318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43319 }
43320 arg2 = static_cast< bool >(val2);
43321 }
43322 {
43323 PyThreadState* __tstate = wxPyBeginAllowThreads();
43324 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43325 wxPyEndAllowThreads(__tstate);
43326 if (PyErr_Occurred()) SWIG_fail;
43327 }
43328 resultobj = SWIG_Py_Void();
43329 return resultobj;
43330 fail:
43331 return NULL;
43332 }
43333
43334
43335 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43336 PyObject *resultobj = 0;
43337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43338 void *argp1 = 0 ;
43339 int res1 = 0 ;
43340 PyObject *swig_obj[1] ;
43341
43342 if (!args) SWIG_fail;
43343 swig_obj[0] = args;
43344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43345 if (!SWIG_IsOK(res1)) {
43346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43347 }
43348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43349 {
43350 PyThreadState* __tstate = wxPyBeginAllowThreads();
43351 wxMenuItem_ResetOwnerDrawn(arg1);
43352 wxPyEndAllowThreads(__tstate);
43353 if (PyErr_Occurred()) SWIG_fail;
43354 }
43355 resultobj = SWIG_Py_Void();
43356 return resultobj;
43357 fail:
43358 return NULL;
43359 }
43360
43361
43362 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43363 PyObject *obj;
43364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43365 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43366 return SWIG_Py_Void();
43367 }
43368
43369 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43370 return SWIG_Python_InitShadowInstance(args);
43371 }
43372
43373 SWIGINTERN int ControlNameStr_set(PyObject *) {
43374 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43375 return 1;
43376 }
43377
43378
43379 SWIGINTERN PyObject *ControlNameStr_get(void) {
43380 PyObject *pyobj = 0;
43381
43382 {
43383 #if wxUSE_UNICODE
43384 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43385 #else
43386 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43387 #endif
43388 }
43389 return pyobj;
43390 }
43391
43392
43393 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43394 PyObject *resultobj = 0;
43395 wxWindow *arg1 = (wxWindow *) 0 ;
43396 int arg2 = (int) -1 ;
43397 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43398 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43399 wxSize const &arg4_defvalue = wxDefaultSize ;
43400 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43401 long arg5 = (long) 0 ;
43402 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43403 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43404 wxString const &arg7_defvalue = wxPyControlNameStr ;
43405 wxString *arg7 = (wxString *) &arg7_defvalue ;
43406 wxControl *result = 0 ;
43407 void *argp1 = 0 ;
43408 int res1 = 0 ;
43409 int val2 ;
43410 int ecode2 = 0 ;
43411 wxPoint temp3 ;
43412 wxSize temp4 ;
43413 long val5 ;
43414 int ecode5 = 0 ;
43415 void *argp6 = 0 ;
43416 int res6 = 0 ;
43417 bool temp7 = false ;
43418 PyObject * obj0 = 0 ;
43419 PyObject * obj1 = 0 ;
43420 PyObject * obj2 = 0 ;
43421 PyObject * obj3 = 0 ;
43422 PyObject * obj4 = 0 ;
43423 PyObject * obj5 = 0 ;
43424 PyObject * obj6 = 0 ;
43425 char * kwnames[] = {
43426 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43427 };
43428
43429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43431 if (!SWIG_IsOK(res1)) {
43432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43433 }
43434 arg1 = reinterpret_cast< wxWindow * >(argp1);
43435 if (obj1) {
43436 ecode2 = SWIG_AsVal_int(obj1, &val2);
43437 if (!SWIG_IsOK(ecode2)) {
43438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43439 }
43440 arg2 = static_cast< int >(val2);
43441 }
43442 if (obj2) {
43443 {
43444 arg3 = &temp3;
43445 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43446 }
43447 }
43448 if (obj3) {
43449 {
43450 arg4 = &temp4;
43451 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43452 }
43453 }
43454 if (obj4) {
43455 ecode5 = SWIG_AsVal_long(obj4, &val5);
43456 if (!SWIG_IsOK(ecode5)) {
43457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43458 }
43459 arg5 = static_cast< long >(val5);
43460 }
43461 if (obj5) {
43462 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43463 if (!SWIG_IsOK(res6)) {
43464 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43465 }
43466 if (!argp6) {
43467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43468 }
43469 arg6 = reinterpret_cast< wxValidator * >(argp6);
43470 }
43471 if (obj6) {
43472 {
43473 arg7 = wxString_in_helper(obj6);
43474 if (arg7 == NULL) SWIG_fail;
43475 temp7 = true;
43476 }
43477 }
43478 {
43479 if (!wxPyCheckForApp()) SWIG_fail;
43480 PyThreadState* __tstate = wxPyBeginAllowThreads();
43481 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43482 wxPyEndAllowThreads(__tstate);
43483 if (PyErr_Occurred()) SWIG_fail;
43484 }
43485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43486 {
43487 if (temp7)
43488 delete arg7;
43489 }
43490 return resultobj;
43491 fail:
43492 {
43493 if (temp7)
43494 delete arg7;
43495 }
43496 return NULL;
43497 }
43498
43499
43500 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43501 PyObject *resultobj = 0;
43502 wxControl *result = 0 ;
43503
43504 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43505 {
43506 if (!wxPyCheckForApp()) SWIG_fail;
43507 PyThreadState* __tstate = wxPyBeginAllowThreads();
43508 result = (wxControl *)new wxControl();
43509 wxPyEndAllowThreads(__tstate);
43510 if (PyErr_Occurred()) SWIG_fail;
43511 }
43512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43513 return resultobj;
43514 fail:
43515 return NULL;
43516 }
43517
43518
43519 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43520 PyObject *resultobj = 0;
43521 wxControl *arg1 = (wxControl *) 0 ;
43522 wxWindow *arg2 = (wxWindow *) 0 ;
43523 int arg3 = (int) -1 ;
43524 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43525 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43526 wxSize const &arg5_defvalue = wxDefaultSize ;
43527 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43528 long arg6 = (long) 0 ;
43529 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43530 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43531 wxString const &arg8_defvalue = wxPyControlNameStr ;
43532 wxString *arg8 = (wxString *) &arg8_defvalue ;
43533 bool result;
43534 void *argp1 = 0 ;
43535 int res1 = 0 ;
43536 void *argp2 = 0 ;
43537 int res2 = 0 ;
43538 int val3 ;
43539 int ecode3 = 0 ;
43540 wxPoint temp4 ;
43541 wxSize temp5 ;
43542 long val6 ;
43543 int ecode6 = 0 ;
43544 void *argp7 = 0 ;
43545 int res7 = 0 ;
43546 bool temp8 = false ;
43547 PyObject * obj0 = 0 ;
43548 PyObject * obj1 = 0 ;
43549 PyObject * obj2 = 0 ;
43550 PyObject * obj3 = 0 ;
43551 PyObject * obj4 = 0 ;
43552 PyObject * obj5 = 0 ;
43553 PyObject * obj6 = 0 ;
43554 PyObject * obj7 = 0 ;
43555 char * kwnames[] = {
43556 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43557 };
43558
43559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43561 if (!SWIG_IsOK(res1)) {
43562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43563 }
43564 arg1 = reinterpret_cast< wxControl * >(argp1);
43565 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43566 if (!SWIG_IsOK(res2)) {
43567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43568 }
43569 arg2 = reinterpret_cast< wxWindow * >(argp2);
43570 if (obj2) {
43571 ecode3 = SWIG_AsVal_int(obj2, &val3);
43572 if (!SWIG_IsOK(ecode3)) {
43573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43574 }
43575 arg3 = static_cast< int >(val3);
43576 }
43577 if (obj3) {
43578 {
43579 arg4 = &temp4;
43580 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43581 }
43582 }
43583 if (obj4) {
43584 {
43585 arg5 = &temp5;
43586 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43587 }
43588 }
43589 if (obj5) {
43590 ecode6 = SWIG_AsVal_long(obj5, &val6);
43591 if (!SWIG_IsOK(ecode6)) {
43592 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43593 }
43594 arg6 = static_cast< long >(val6);
43595 }
43596 if (obj6) {
43597 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43598 if (!SWIG_IsOK(res7)) {
43599 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43600 }
43601 if (!argp7) {
43602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43603 }
43604 arg7 = reinterpret_cast< wxValidator * >(argp7);
43605 }
43606 if (obj7) {
43607 {
43608 arg8 = wxString_in_helper(obj7);
43609 if (arg8 == NULL) SWIG_fail;
43610 temp8 = true;
43611 }
43612 }
43613 {
43614 PyThreadState* __tstate = wxPyBeginAllowThreads();
43615 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43616 wxPyEndAllowThreads(__tstate);
43617 if (PyErr_Occurred()) SWIG_fail;
43618 }
43619 {
43620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43621 }
43622 {
43623 if (temp8)
43624 delete arg8;
43625 }
43626 return resultobj;
43627 fail:
43628 {
43629 if (temp8)
43630 delete arg8;
43631 }
43632 return NULL;
43633 }
43634
43635
43636 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43637 PyObject *resultobj = 0;
43638 wxControl *arg1 = (wxControl *) 0 ;
43639 wxCommandEvent *arg2 = 0 ;
43640 void *argp1 = 0 ;
43641 int res1 = 0 ;
43642 void *argp2 = 0 ;
43643 int res2 = 0 ;
43644 PyObject * obj0 = 0 ;
43645 PyObject * obj1 = 0 ;
43646 char * kwnames[] = {
43647 (char *) "self",(char *) "event", NULL
43648 };
43649
43650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43652 if (!SWIG_IsOK(res1)) {
43653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43654 }
43655 arg1 = reinterpret_cast< wxControl * >(argp1);
43656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43657 if (!SWIG_IsOK(res2)) {
43658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43659 }
43660 if (!argp2) {
43661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43662 }
43663 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43664 {
43665 PyThreadState* __tstate = wxPyBeginAllowThreads();
43666 (arg1)->Command(*arg2);
43667 wxPyEndAllowThreads(__tstate);
43668 if (PyErr_Occurred()) SWIG_fail;
43669 }
43670 resultobj = SWIG_Py_Void();
43671 return resultobj;
43672 fail:
43673 return NULL;
43674 }
43675
43676
43677 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43678 PyObject *resultobj = 0;
43679 wxControl *arg1 = (wxControl *) 0 ;
43680 wxString result;
43681 void *argp1 = 0 ;
43682 int res1 = 0 ;
43683 PyObject *swig_obj[1] ;
43684
43685 if (!args) SWIG_fail;
43686 swig_obj[0] = args;
43687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43688 if (!SWIG_IsOK(res1)) {
43689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43690 }
43691 arg1 = reinterpret_cast< wxControl * >(argp1);
43692 {
43693 PyThreadState* __tstate = wxPyBeginAllowThreads();
43694 result = (arg1)->GetLabel();
43695 wxPyEndAllowThreads(__tstate);
43696 if (PyErr_Occurred()) SWIG_fail;
43697 }
43698 {
43699 #if wxUSE_UNICODE
43700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43701 #else
43702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43703 #endif
43704 }
43705 return resultobj;
43706 fail:
43707 return NULL;
43708 }
43709
43710
43711 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43712 PyObject *resultobj = 0;
43713 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43714 SwigValueWrapper<wxVisualAttributes > result;
43715 int val1 ;
43716 int ecode1 = 0 ;
43717 PyObject * obj0 = 0 ;
43718 char * kwnames[] = {
43719 (char *) "variant", NULL
43720 };
43721
43722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43723 if (obj0) {
43724 ecode1 = SWIG_AsVal_int(obj0, &val1);
43725 if (!SWIG_IsOK(ecode1)) {
43726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43727 }
43728 arg1 = static_cast< wxWindowVariant >(val1);
43729 }
43730 {
43731 if (!wxPyCheckForApp()) SWIG_fail;
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = wxControl::GetClassDefaultAttributes(arg1);
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43745 PyObject *obj;
43746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43747 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43748 return SWIG_Py_Void();
43749 }
43750
43751 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43752 return SWIG_Python_InitShadowInstance(args);
43753 }
43754
43755 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43756 PyObject *resultobj = 0;
43757 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43758 wxString *arg2 = 0 ;
43759 PyObject *arg3 = (PyObject *) NULL ;
43760 int result;
43761 void *argp1 = 0 ;
43762 int res1 = 0 ;
43763 bool temp2 = false ;
43764 PyObject * obj0 = 0 ;
43765 PyObject * obj1 = 0 ;
43766 PyObject * obj2 = 0 ;
43767 char * kwnames[] = {
43768 (char *) "self",(char *) "item",(char *) "clientData", NULL
43769 };
43770
43771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43773 if (!SWIG_IsOK(res1)) {
43774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43775 }
43776 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43777 {
43778 arg2 = wxString_in_helper(obj1);
43779 if (arg2 == NULL) SWIG_fail;
43780 temp2 = true;
43781 }
43782 if (obj2) {
43783 arg3 = obj2;
43784 }
43785 {
43786 PyThreadState* __tstate = wxPyBeginAllowThreads();
43787 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43788 wxPyEndAllowThreads(__tstate);
43789 if (PyErr_Occurred()) SWIG_fail;
43790 }
43791 resultobj = SWIG_From_int(static_cast< int >(result));
43792 {
43793 if (temp2)
43794 delete arg2;
43795 }
43796 return resultobj;
43797 fail:
43798 {
43799 if (temp2)
43800 delete arg2;
43801 }
43802 return NULL;
43803 }
43804
43805
43806 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43807 PyObject *resultobj = 0;
43808 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43809 wxArrayString *arg2 = 0 ;
43810 void *argp1 = 0 ;
43811 int res1 = 0 ;
43812 bool temp2 = false ;
43813 PyObject * obj0 = 0 ;
43814 PyObject * obj1 = 0 ;
43815 char * kwnames[] = {
43816 (char *) "self",(char *) "strings", NULL
43817 };
43818
43819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43821 if (!SWIG_IsOK(res1)) {
43822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43823 }
43824 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43825 {
43826 if (! PySequence_Check(obj1)) {
43827 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43828 SWIG_fail;
43829 }
43830 arg2 = new wxArrayString;
43831 temp2 = true;
43832 int i, len=PySequence_Length(obj1);
43833 for (i=0; i<len; i++) {
43834 PyObject* item = PySequence_GetItem(obj1, i);
43835 wxString* s = wxString_in_helper(item);
43836 if (PyErr_Occurred()) SWIG_fail;
43837 arg2->Add(*s);
43838 delete s;
43839 Py_DECREF(item);
43840 }
43841 }
43842 {
43843 PyThreadState* __tstate = wxPyBeginAllowThreads();
43844 (arg1)->Append((wxArrayString const &)*arg2);
43845 wxPyEndAllowThreads(__tstate);
43846 if (PyErr_Occurred()) SWIG_fail;
43847 }
43848 resultobj = SWIG_Py_Void();
43849 {
43850 if (temp2) delete arg2;
43851 }
43852 return resultobj;
43853 fail:
43854 {
43855 if (temp2) delete arg2;
43856 }
43857 return NULL;
43858 }
43859
43860
43861 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43862 PyObject *resultobj = 0;
43863 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43864 wxString *arg2 = 0 ;
43865 int arg3 ;
43866 PyObject *arg4 = (PyObject *) NULL ;
43867 int result;
43868 void *argp1 = 0 ;
43869 int res1 = 0 ;
43870 bool temp2 = false ;
43871 int val3 ;
43872 int ecode3 = 0 ;
43873 PyObject * obj0 = 0 ;
43874 PyObject * obj1 = 0 ;
43875 PyObject * obj2 = 0 ;
43876 PyObject * obj3 = 0 ;
43877 char * kwnames[] = {
43878 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43879 };
43880
43881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43883 if (!SWIG_IsOK(res1)) {
43884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43885 }
43886 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43887 {
43888 arg2 = wxString_in_helper(obj1);
43889 if (arg2 == NULL) SWIG_fail;
43890 temp2 = true;
43891 }
43892 ecode3 = SWIG_AsVal_int(obj2, &val3);
43893 if (!SWIG_IsOK(ecode3)) {
43894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43895 }
43896 arg3 = static_cast< int >(val3);
43897 if (obj3) {
43898 arg4 = obj3;
43899 }
43900 {
43901 PyThreadState* __tstate = wxPyBeginAllowThreads();
43902 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 resultobj = SWIG_From_int(static_cast< int >(result));
43907 {
43908 if (temp2)
43909 delete arg2;
43910 }
43911 return resultobj;
43912 fail:
43913 {
43914 if (temp2)
43915 delete arg2;
43916 }
43917 return NULL;
43918 }
43919
43920
43921 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43922 PyObject *resultobj = 0;
43923 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43924 void *argp1 = 0 ;
43925 int res1 = 0 ;
43926 PyObject *swig_obj[1] ;
43927
43928 if (!args) SWIG_fail;
43929 swig_obj[0] = args;
43930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43931 if (!SWIG_IsOK(res1)) {
43932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43933 }
43934 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43935 {
43936 PyThreadState* __tstate = wxPyBeginAllowThreads();
43937 (arg1)->Clear();
43938 wxPyEndAllowThreads(__tstate);
43939 if (PyErr_Occurred()) SWIG_fail;
43940 }
43941 resultobj = SWIG_Py_Void();
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43949 PyObject *resultobj = 0;
43950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43951 int arg2 ;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 int val2 ;
43955 int ecode2 = 0 ;
43956 PyObject * obj0 = 0 ;
43957 PyObject * obj1 = 0 ;
43958 char * kwnames[] = {
43959 (char *) "self",(char *) "n", NULL
43960 };
43961
43962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43964 if (!SWIG_IsOK(res1)) {
43965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43966 }
43967 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43968 ecode2 = SWIG_AsVal_int(obj1, &val2);
43969 if (!SWIG_IsOK(ecode2)) {
43970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43971 }
43972 arg2 = static_cast< int >(val2);
43973 {
43974 PyThreadState* __tstate = wxPyBeginAllowThreads();
43975 (arg1)->Delete(arg2);
43976 wxPyEndAllowThreads(__tstate);
43977 if (PyErr_Occurred()) SWIG_fail;
43978 }
43979 resultobj = SWIG_Py_Void();
43980 return resultobj;
43981 fail:
43982 return NULL;
43983 }
43984
43985
43986 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43987 PyObject *resultobj = 0;
43988 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43989 int arg2 ;
43990 PyObject *result = 0 ;
43991 void *argp1 = 0 ;
43992 int res1 = 0 ;
43993 int val2 ;
43994 int ecode2 = 0 ;
43995 PyObject * obj0 = 0 ;
43996 PyObject * obj1 = 0 ;
43997 char * kwnames[] = {
43998 (char *) "self",(char *) "n", NULL
43999 };
44000
44001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44003 if (!SWIG_IsOK(res1)) {
44004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44005 }
44006 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44007 ecode2 = SWIG_AsVal_int(obj1, &val2);
44008 if (!SWIG_IsOK(ecode2)) {
44009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
44010 }
44011 arg2 = static_cast< int >(val2);
44012 {
44013 PyThreadState* __tstate = wxPyBeginAllowThreads();
44014 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44015 wxPyEndAllowThreads(__tstate);
44016 if (PyErr_Occurred()) SWIG_fail;
44017 }
44018 resultobj = result;
44019 return resultobj;
44020 fail:
44021 return NULL;
44022 }
44023
44024
44025 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44026 PyObject *resultobj = 0;
44027 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44028 int arg2 ;
44029 PyObject *arg3 = (PyObject *) 0 ;
44030 void *argp1 = 0 ;
44031 int res1 = 0 ;
44032 int val2 ;
44033 int ecode2 = 0 ;
44034 PyObject * obj0 = 0 ;
44035 PyObject * obj1 = 0 ;
44036 PyObject * obj2 = 0 ;
44037 char * kwnames[] = {
44038 (char *) "self",(char *) "n",(char *) "clientData", NULL
44039 };
44040
44041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44043 if (!SWIG_IsOK(res1)) {
44044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44045 }
44046 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44047 ecode2 = SWIG_AsVal_int(obj1, &val2);
44048 if (!SWIG_IsOK(ecode2)) {
44049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
44050 }
44051 arg2 = static_cast< int >(val2);
44052 arg3 = obj2;
44053 {
44054 PyThreadState* __tstate = wxPyBeginAllowThreads();
44055 wxItemContainer_SetClientData(arg1,arg2,arg3);
44056 wxPyEndAllowThreads(__tstate);
44057 if (PyErr_Occurred()) SWIG_fail;
44058 }
44059 resultobj = SWIG_Py_Void();
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44067 PyObject *resultobj = 0;
44068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44069 size_t result;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 PyObject *swig_obj[1] ;
44073
44074 if (!args) SWIG_fail;
44075 swig_obj[0] = args;
44076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44077 if (!SWIG_IsOK(res1)) {
44078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44079 }
44080 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 result = (size_t)((wxItemContainer const *)arg1)->GetCount();
44084 wxPyEndAllowThreads(__tstate);
44085 if (PyErr_Occurred()) SWIG_fail;
44086 }
44087 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44088 return resultobj;
44089 fail:
44090 return NULL;
44091 }
44092
44093
44094 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44095 PyObject *resultobj = 0;
44096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44097 bool result;
44098 void *argp1 = 0 ;
44099 int res1 = 0 ;
44100 PyObject *swig_obj[1] ;
44101
44102 if (!args) SWIG_fail;
44103 swig_obj[0] = args;
44104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44105 if (!SWIG_IsOK(res1)) {
44106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44107 }
44108 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 {
44116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44117 }
44118 return resultobj;
44119 fail:
44120 return NULL;
44121 }
44122
44123
44124 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44125 PyObject *resultobj = 0;
44126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44127 int arg2 ;
44128 wxString result;
44129 void *argp1 = 0 ;
44130 int res1 = 0 ;
44131 int val2 ;
44132 int ecode2 = 0 ;
44133 PyObject * obj0 = 0 ;
44134 PyObject * obj1 = 0 ;
44135 char * kwnames[] = {
44136 (char *) "self",(char *) "n", NULL
44137 };
44138
44139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44141 if (!SWIG_IsOK(res1)) {
44142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44143 }
44144 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44145 ecode2 = SWIG_AsVal_int(obj1, &val2);
44146 if (!SWIG_IsOK(ecode2)) {
44147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44148 }
44149 arg2 = static_cast< int >(val2);
44150 {
44151 PyThreadState* __tstate = wxPyBeginAllowThreads();
44152 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44153 wxPyEndAllowThreads(__tstate);
44154 if (PyErr_Occurred()) SWIG_fail;
44155 }
44156 {
44157 #if wxUSE_UNICODE
44158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44159 #else
44160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44161 #endif
44162 }
44163 return resultobj;
44164 fail:
44165 return NULL;
44166 }
44167
44168
44169 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44170 PyObject *resultobj = 0;
44171 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44172 wxArrayString result;
44173 void *argp1 = 0 ;
44174 int res1 = 0 ;
44175 PyObject *swig_obj[1] ;
44176
44177 if (!args) SWIG_fail;
44178 swig_obj[0] = args;
44179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44180 if (!SWIG_IsOK(res1)) {
44181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44182 }
44183 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44184 {
44185 PyThreadState* __tstate = wxPyBeginAllowThreads();
44186 result = ((wxItemContainer const *)arg1)->GetStrings();
44187 wxPyEndAllowThreads(__tstate);
44188 if (PyErr_Occurred()) SWIG_fail;
44189 }
44190 {
44191 resultobj = wxArrayString2PyList_helper(result);
44192 }
44193 return resultobj;
44194 fail:
44195 return NULL;
44196 }
44197
44198
44199 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44200 PyObject *resultobj = 0;
44201 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44202 int arg2 ;
44203 wxString *arg3 = 0 ;
44204 void *argp1 = 0 ;
44205 int res1 = 0 ;
44206 int val2 ;
44207 int ecode2 = 0 ;
44208 bool temp3 = false ;
44209 PyObject * obj0 = 0 ;
44210 PyObject * obj1 = 0 ;
44211 PyObject * obj2 = 0 ;
44212 char * kwnames[] = {
44213 (char *) "self",(char *) "n",(char *) "s", NULL
44214 };
44215
44216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44218 if (!SWIG_IsOK(res1)) {
44219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44220 }
44221 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44222 ecode2 = SWIG_AsVal_int(obj1, &val2);
44223 if (!SWIG_IsOK(ecode2)) {
44224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44225 }
44226 arg2 = static_cast< int >(val2);
44227 {
44228 arg3 = wxString_in_helper(obj2);
44229 if (arg3 == NULL) SWIG_fail;
44230 temp3 = true;
44231 }
44232 {
44233 PyThreadState* __tstate = wxPyBeginAllowThreads();
44234 (arg1)->SetString(arg2,(wxString const &)*arg3);
44235 wxPyEndAllowThreads(__tstate);
44236 if (PyErr_Occurred()) SWIG_fail;
44237 }
44238 resultobj = SWIG_Py_Void();
44239 {
44240 if (temp3)
44241 delete arg3;
44242 }
44243 return resultobj;
44244 fail:
44245 {
44246 if (temp3)
44247 delete arg3;
44248 }
44249 return NULL;
44250 }
44251
44252
44253 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44254 PyObject *resultobj = 0;
44255 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44256 wxString *arg2 = 0 ;
44257 int result;
44258 void *argp1 = 0 ;
44259 int res1 = 0 ;
44260 bool temp2 = false ;
44261 PyObject * obj0 = 0 ;
44262 PyObject * obj1 = 0 ;
44263 char * kwnames[] = {
44264 (char *) "self",(char *) "s", NULL
44265 };
44266
44267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44269 if (!SWIG_IsOK(res1)) {
44270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44271 }
44272 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44273 {
44274 arg2 = wxString_in_helper(obj1);
44275 if (arg2 == NULL) SWIG_fail;
44276 temp2 = true;
44277 }
44278 {
44279 PyThreadState* __tstate = wxPyBeginAllowThreads();
44280 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44281 wxPyEndAllowThreads(__tstate);
44282 if (PyErr_Occurred()) SWIG_fail;
44283 }
44284 resultobj = SWIG_From_int(static_cast< int >(result));
44285 {
44286 if (temp2)
44287 delete arg2;
44288 }
44289 return resultobj;
44290 fail:
44291 {
44292 if (temp2)
44293 delete arg2;
44294 }
44295 return NULL;
44296 }
44297
44298
44299 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44300 PyObject *resultobj = 0;
44301 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44302 int arg2 ;
44303 void *argp1 = 0 ;
44304 int res1 = 0 ;
44305 int val2 ;
44306 int ecode2 = 0 ;
44307 PyObject * obj0 = 0 ;
44308 PyObject * obj1 = 0 ;
44309 char * kwnames[] = {
44310 (char *) "self",(char *) "n", NULL
44311 };
44312
44313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44315 if (!SWIG_IsOK(res1)) {
44316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44317 }
44318 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44319 ecode2 = SWIG_AsVal_int(obj1, &val2);
44320 if (!SWIG_IsOK(ecode2)) {
44321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44322 }
44323 arg2 = static_cast< int >(val2);
44324 {
44325 PyThreadState* __tstate = wxPyBeginAllowThreads();
44326 (arg1)->SetSelection(arg2);
44327 wxPyEndAllowThreads(__tstate);
44328 if (PyErr_Occurred()) SWIG_fail;
44329 }
44330 resultobj = SWIG_Py_Void();
44331 return resultobj;
44332 fail:
44333 return NULL;
44334 }
44335
44336
44337 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44338 PyObject *resultobj = 0;
44339 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44340 int result;
44341 void *argp1 = 0 ;
44342 int res1 = 0 ;
44343 PyObject *swig_obj[1] ;
44344
44345 if (!args) SWIG_fail;
44346 swig_obj[0] = args;
44347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44348 if (!SWIG_IsOK(res1)) {
44349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44350 }
44351 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 resultobj = SWIG_From_int(static_cast< int >(result));
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44366 PyObject *resultobj = 0;
44367 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44368 wxString *arg2 = 0 ;
44369 bool result;
44370 void *argp1 = 0 ;
44371 int res1 = 0 ;
44372 bool temp2 = false ;
44373 PyObject * obj0 = 0 ;
44374 PyObject * obj1 = 0 ;
44375 char * kwnames[] = {
44376 (char *) "self",(char *) "s", NULL
44377 };
44378
44379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44381 if (!SWIG_IsOK(res1)) {
44382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44383 }
44384 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44385 {
44386 arg2 = wxString_in_helper(obj1);
44387 if (arg2 == NULL) SWIG_fail;
44388 temp2 = true;
44389 }
44390 {
44391 PyThreadState* __tstate = wxPyBeginAllowThreads();
44392 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44393 wxPyEndAllowThreads(__tstate);
44394 if (PyErr_Occurred()) SWIG_fail;
44395 }
44396 {
44397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44398 }
44399 {
44400 if (temp2)
44401 delete arg2;
44402 }
44403 return resultobj;
44404 fail:
44405 {
44406 if (temp2)
44407 delete arg2;
44408 }
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44414 PyObject *resultobj = 0;
44415 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44416 wxString result;
44417 void *argp1 = 0 ;
44418 int res1 = 0 ;
44419 PyObject *swig_obj[1] ;
44420
44421 if (!args) SWIG_fail;
44422 swig_obj[0] = args;
44423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44426 }
44427 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44431 wxPyEndAllowThreads(__tstate);
44432 if (PyErr_Occurred()) SWIG_fail;
44433 }
44434 {
44435 #if wxUSE_UNICODE
44436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44437 #else
44438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44439 #endif
44440 }
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj = 0;
44449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44450 int arg2 ;
44451 void *argp1 = 0 ;
44452 int res1 = 0 ;
44453 int val2 ;
44454 int ecode2 = 0 ;
44455 PyObject * obj0 = 0 ;
44456 PyObject * obj1 = 0 ;
44457 char * kwnames[] = {
44458 (char *) "self",(char *) "n", NULL
44459 };
44460
44461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44463 if (!SWIG_IsOK(res1)) {
44464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44465 }
44466 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44467 ecode2 = SWIG_AsVal_int(obj1, &val2);
44468 if (!SWIG_IsOK(ecode2)) {
44469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44470 }
44471 arg2 = static_cast< int >(val2);
44472 {
44473 PyThreadState* __tstate = wxPyBeginAllowThreads();
44474 (arg1)->Select(arg2);
44475 wxPyEndAllowThreads(__tstate);
44476 if (PyErr_Occurred()) SWIG_fail;
44477 }
44478 resultobj = SWIG_Py_Void();
44479 return resultobj;
44480 fail:
44481 return NULL;
44482 }
44483
44484
44485 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44486 PyObject *obj;
44487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44488 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44489 return SWIG_Py_Void();
44490 }
44491
44492 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44493 PyObject *obj;
44494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44495 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44496 return SWIG_Py_Void();
44497 }
44498
44499 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44500 PyObject *resultobj = 0;
44501 wxSizerItem *result = 0 ;
44502
44503 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 result = (wxSizerItem *)new wxSizerItem();
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44518 PyObject *resultobj = 0;
44519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44520 void *argp1 = 0 ;
44521 int res1 = 0 ;
44522 PyObject *swig_obj[1] ;
44523
44524 if (!args) SWIG_fail;
44525 swig_obj[0] = args;
44526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44527 if (!SWIG_IsOK(res1)) {
44528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44529 }
44530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44531 {
44532 PyThreadState* __tstate = wxPyBeginAllowThreads();
44533 delete arg1;
44534
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 resultobj = SWIG_Py_Void();
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj = 0;
44547 wxWindow *arg1 = (wxWindow *) 0 ;
44548 int arg2 ;
44549 int arg3 ;
44550 int arg4 ;
44551 PyObject *arg5 = (PyObject *) NULL ;
44552 wxSizerItem *result = 0 ;
44553 void *argp1 = 0 ;
44554 int res1 = 0 ;
44555 int val2 ;
44556 int ecode2 = 0 ;
44557 int val3 ;
44558 int ecode3 = 0 ;
44559 int val4 ;
44560 int ecode4 = 0 ;
44561 PyObject * obj0 = 0 ;
44562 PyObject * obj1 = 0 ;
44563 PyObject * obj2 = 0 ;
44564 PyObject * obj3 = 0 ;
44565 PyObject * obj4 = 0 ;
44566 char * kwnames[] = {
44567 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44568 };
44569
44570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44572 if (!SWIG_IsOK(res1)) {
44573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44574 }
44575 arg1 = reinterpret_cast< wxWindow * >(argp1);
44576 ecode2 = SWIG_AsVal_int(obj1, &val2);
44577 if (!SWIG_IsOK(ecode2)) {
44578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44579 }
44580 arg2 = static_cast< int >(val2);
44581 ecode3 = SWIG_AsVal_int(obj2, &val3);
44582 if (!SWIG_IsOK(ecode3)) {
44583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44584 }
44585 arg3 = static_cast< int >(val3);
44586 ecode4 = SWIG_AsVal_int(obj3, &val4);
44587 if (!SWIG_IsOK(ecode4)) {
44588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44589 }
44590 arg4 = static_cast< int >(val4);
44591 if (obj4) {
44592 arg5 = obj4;
44593 }
44594 {
44595 PyThreadState* __tstate = wxPyBeginAllowThreads();
44596 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44597 wxPyEndAllowThreads(__tstate);
44598 if (PyErr_Occurred()) SWIG_fail;
44599 }
44600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44601 return resultobj;
44602 fail:
44603 return NULL;
44604 }
44605
44606
44607 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44608 PyObject *resultobj = 0;
44609 int arg1 ;
44610 int arg2 ;
44611 int arg3 ;
44612 int arg4 ;
44613 int arg5 ;
44614 PyObject *arg6 = (PyObject *) NULL ;
44615 wxSizerItem *result = 0 ;
44616 int val1 ;
44617 int ecode1 = 0 ;
44618 int val2 ;
44619 int ecode2 = 0 ;
44620 int val3 ;
44621 int ecode3 = 0 ;
44622 int val4 ;
44623 int ecode4 = 0 ;
44624 int val5 ;
44625 int ecode5 = 0 ;
44626 PyObject * obj0 = 0 ;
44627 PyObject * obj1 = 0 ;
44628 PyObject * obj2 = 0 ;
44629 PyObject * obj3 = 0 ;
44630 PyObject * obj4 = 0 ;
44631 PyObject * obj5 = 0 ;
44632 char * kwnames[] = {
44633 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44634 };
44635
44636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44637 ecode1 = SWIG_AsVal_int(obj0, &val1);
44638 if (!SWIG_IsOK(ecode1)) {
44639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44640 }
44641 arg1 = static_cast< int >(val1);
44642 ecode2 = SWIG_AsVal_int(obj1, &val2);
44643 if (!SWIG_IsOK(ecode2)) {
44644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44645 }
44646 arg2 = static_cast< int >(val2);
44647 ecode3 = SWIG_AsVal_int(obj2, &val3);
44648 if (!SWIG_IsOK(ecode3)) {
44649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44650 }
44651 arg3 = static_cast< int >(val3);
44652 ecode4 = SWIG_AsVal_int(obj3, &val4);
44653 if (!SWIG_IsOK(ecode4)) {
44654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44655 }
44656 arg4 = static_cast< int >(val4);
44657 ecode5 = SWIG_AsVal_int(obj4, &val5);
44658 if (!SWIG_IsOK(ecode5)) {
44659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44660 }
44661 arg5 = static_cast< int >(val5);
44662 if (obj5) {
44663 arg6 = obj5;
44664 }
44665 {
44666 PyThreadState* __tstate = wxPyBeginAllowThreads();
44667 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44668 wxPyEndAllowThreads(__tstate);
44669 if (PyErr_Occurred()) SWIG_fail;
44670 }
44671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44672 return resultobj;
44673 fail:
44674 return NULL;
44675 }
44676
44677
44678 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44679 PyObject *resultobj = 0;
44680 wxSizer *arg1 = (wxSizer *) 0 ;
44681 int arg2 ;
44682 int arg3 ;
44683 int arg4 ;
44684 PyObject *arg5 = (PyObject *) NULL ;
44685 wxSizerItem *result = 0 ;
44686 int res1 = 0 ;
44687 int val2 ;
44688 int ecode2 = 0 ;
44689 int val3 ;
44690 int ecode3 = 0 ;
44691 int val4 ;
44692 int ecode4 = 0 ;
44693 PyObject * obj0 = 0 ;
44694 PyObject * obj1 = 0 ;
44695 PyObject * obj2 = 0 ;
44696 PyObject * obj3 = 0 ;
44697 PyObject * obj4 = 0 ;
44698 char * kwnames[] = {
44699 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44700 };
44701
44702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44703 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44704 if (!SWIG_IsOK(res1)) {
44705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44706 }
44707 ecode2 = SWIG_AsVal_int(obj1, &val2);
44708 if (!SWIG_IsOK(ecode2)) {
44709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44710 }
44711 arg2 = static_cast< int >(val2);
44712 ecode3 = SWIG_AsVal_int(obj2, &val3);
44713 if (!SWIG_IsOK(ecode3)) {
44714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44715 }
44716 arg3 = static_cast< int >(val3);
44717 ecode4 = SWIG_AsVal_int(obj3, &val4);
44718 if (!SWIG_IsOK(ecode4)) {
44719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44720 }
44721 arg4 = static_cast< int >(val4);
44722 if (obj4) {
44723 arg5 = obj4;
44724 }
44725 {
44726 PyThreadState* __tstate = wxPyBeginAllowThreads();
44727 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44728 wxPyEndAllowThreads(__tstate);
44729 if (PyErr_Occurred()) SWIG_fail;
44730 }
44731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44732 return resultobj;
44733 fail:
44734 return NULL;
44735 }
44736
44737
44738 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44739 PyObject *resultobj = 0;
44740 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44741 void *argp1 = 0 ;
44742 int res1 = 0 ;
44743 PyObject *swig_obj[1] ;
44744
44745 if (!args) SWIG_fail;
44746 swig_obj[0] = args;
44747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44748 if (!SWIG_IsOK(res1)) {
44749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44750 }
44751 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44752 {
44753 PyThreadState* __tstate = wxPyBeginAllowThreads();
44754 (arg1)->DeleteWindows();
44755 wxPyEndAllowThreads(__tstate);
44756 if (PyErr_Occurred()) SWIG_fail;
44757 }
44758 resultobj = SWIG_Py_Void();
44759 return resultobj;
44760 fail:
44761 return NULL;
44762 }
44763
44764
44765 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44766 PyObject *resultobj = 0;
44767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44768 void *argp1 = 0 ;
44769 int res1 = 0 ;
44770 PyObject *swig_obj[1] ;
44771
44772 if (!args) SWIG_fail;
44773 swig_obj[0] = args;
44774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44775 if (!SWIG_IsOK(res1)) {
44776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44777 }
44778 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44779 {
44780 PyThreadState* __tstate = wxPyBeginAllowThreads();
44781 (arg1)->DetachSizer();
44782 wxPyEndAllowThreads(__tstate);
44783 if (PyErr_Occurred()) SWIG_fail;
44784 }
44785 resultobj = SWIG_Py_Void();
44786 return resultobj;
44787 fail:
44788 return NULL;
44789 }
44790
44791
44792 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44793 PyObject *resultobj = 0;
44794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44795 wxSize result;
44796 void *argp1 = 0 ;
44797 int res1 = 0 ;
44798 PyObject *swig_obj[1] ;
44799
44800 if (!args) SWIG_fail;
44801 swig_obj[0] = args;
44802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44805 }
44806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44807 {
44808 PyThreadState* __tstate = wxPyBeginAllowThreads();
44809 result = (arg1)->GetSize();
44810 wxPyEndAllowThreads(__tstate);
44811 if (PyErr_Occurred()) SWIG_fail;
44812 }
44813 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44821 PyObject *resultobj = 0;
44822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44823 wxSize result;
44824 void *argp1 = 0 ;
44825 int res1 = 0 ;
44826 PyObject *swig_obj[1] ;
44827
44828 if (!args) SWIG_fail;
44829 swig_obj[0] = args;
44830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44831 if (!SWIG_IsOK(res1)) {
44832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44833 }
44834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44835 {
44836 PyThreadState* __tstate = wxPyBeginAllowThreads();
44837 result = (arg1)->CalcMin();
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44842 return resultobj;
44843 fail:
44844 return NULL;
44845 }
44846
44847
44848 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44849 PyObject *resultobj = 0;
44850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44851 wxPoint *arg2 = 0 ;
44852 wxSize *arg3 = 0 ;
44853 void *argp1 = 0 ;
44854 int res1 = 0 ;
44855 wxPoint temp2 ;
44856 wxSize temp3 ;
44857 PyObject * obj0 = 0 ;
44858 PyObject * obj1 = 0 ;
44859 PyObject * obj2 = 0 ;
44860 char * kwnames[] = {
44861 (char *) "self",(char *) "pos",(char *) "size", NULL
44862 };
44863
44864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44866 if (!SWIG_IsOK(res1)) {
44867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44868 }
44869 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44870 {
44871 arg2 = &temp2;
44872 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44873 }
44874 {
44875 arg3 = &temp3;
44876 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44877 }
44878 {
44879 PyThreadState* __tstate = wxPyBeginAllowThreads();
44880 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44881 wxPyEndAllowThreads(__tstate);
44882 if (PyErr_Occurred()) SWIG_fail;
44883 }
44884 resultobj = SWIG_Py_Void();
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44892 PyObject *resultobj = 0;
44893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44894 wxSize result;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 PyObject *swig_obj[1] ;
44898
44899 if (!args) SWIG_fail;
44900 swig_obj[0] = args;
44901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44902 if (!SWIG_IsOK(res1)) {
44903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44904 }
44905 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 result = (arg1)->GetMinSize();
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44920 PyObject *resultobj = 0;
44921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44922 wxSize result;
44923 void *argp1 = 0 ;
44924 int res1 = 0 ;
44925 PyObject *swig_obj[1] ;
44926
44927 if (!args) SWIG_fail;
44928 swig_obj[0] = args;
44929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44930 if (!SWIG_IsOK(res1)) {
44931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44932 }
44933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44934 {
44935 PyThreadState* __tstate = wxPyBeginAllowThreads();
44936 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44937 wxPyEndAllowThreads(__tstate);
44938 if (PyErr_Occurred()) SWIG_fail;
44939 }
44940 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj = 0;
44949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44950 int arg2 ;
44951 int arg3 ;
44952 void *argp1 = 0 ;
44953 int res1 = 0 ;
44954 int val2 ;
44955 int ecode2 = 0 ;
44956 int val3 ;
44957 int ecode3 = 0 ;
44958 PyObject * obj0 = 0 ;
44959 PyObject * obj1 = 0 ;
44960 PyObject * obj2 = 0 ;
44961 char * kwnames[] = {
44962 (char *) "self",(char *) "x",(char *) "y", NULL
44963 };
44964
44965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44967 if (!SWIG_IsOK(res1)) {
44968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44969 }
44970 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44971 ecode2 = SWIG_AsVal_int(obj1, &val2);
44972 if (!SWIG_IsOK(ecode2)) {
44973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
44974 }
44975 arg2 = static_cast< int >(val2);
44976 ecode3 = SWIG_AsVal_int(obj2, &val3);
44977 if (!SWIG_IsOK(ecode3)) {
44978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
44979 }
44980 arg3 = static_cast< int >(val3);
44981 {
44982 PyThreadState* __tstate = wxPyBeginAllowThreads();
44983 (arg1)->SetInitSize(arg2,arg3);
44984 wxPyEndAllowThreads(__tstate);
44985 if (PyErr_Occurred()) SWIG_fail;
44986 }
44987 resultobj = SWIG_Py_Void();
44988 return resultobj;
44989 fail:
44990 return NULL;
44991 }
44992
44993
44994 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44995 PyObject *resultobj = 0;
44996 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44997 int arg2 ;
44998 int arg3 ;
44999 void *argp1 = 0 ;
45000 int res1 = 0 ;
45001 int val2 ;
45002 int ecode2 = 0 ;
45003 int val3 ;
45004 int ecode3 = 0 ;
45005 PyObject * obj0 = 0 ;
45006 PyObject * obj1 = 0 ;
45007 PyObject * obj2 = 0 ;
45008 char * kwnames[] = {
45009 (char *) "self",(char *) "width",(char *) "height", NULL
45010 };
45011
45012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45014 if (!SWIG_IsOK(res1)) {
45015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45016 }
45017 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45018 ecode2 = SWIG_AsVal_int(obj1, &val2);
45019 if (!SWIG_IsOK(ecode2)) {
45020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45021 }
45022 arg2 = static_cast< int >(val2);
45023 ecode3 = SWIG_AsVal_int(obj2, &val3);
45024 if (!SWIG_IsOK(ecode3)) {
45025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45026 }
45027 arg3 = static_cast< int >(val3);
45028 {
45029 PyThreadState* __tstate = wxPyBeginAllowThreads();
45030 (arg1)->SetRatio(arg2,arg3);
45031 wxPyEndAllowThreads(__tstate);
45032 if (PyErr_Occurred()) SWIG_fail;
45033 }
45034 resultobj = SWIG_Py_Void();
45035 return resultobj;
45036 fail:
45037 return NULL;
45038 }
45039
45040
45041 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45042 PyObject *resultobj = 0;
45043 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45044 wxSize *arg2 = 0 ;
45045 void *argp1 = 0 ;
45046 int res1 = 0 ;
45047 wxSize temp2 ;
45048 PyObject * obj0 = 0 ;
45049 PyObject * obj1 = 0 ;
45050 char * kwnames[] = {
45051 (char *) "self",(char *) "size", NULL
45052 };
45053
45054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45056 if (!SWIG_IsOK(res1)) {
45057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45058 }
45059 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45060 {
45061 arg2 = &temp2;
45062 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45063 }
45064 {
45065 PyThreadState* __tstate = wxPyBeginAllowThreads();
45066 (arg1)->SetRatio((wxSize const &)*arg2);
45067 wxPyEndAllowThreads(__tstate);
45068 if (PyErr_Occurred()) SWIG_fail;
45069 }
45070 resultobj = SWIG_Py_Void();
45071 return resultobj;
45072 fail:
45073 return NULL;
45074 }
45075
45076
45077 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45078 PyObject *resultobj = 0;
45079 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45080 float arg2 ;
45081 void *argp1 = 0 ;
45082 int res1 = 0 ;
45083 float val2 ;
45084 int ecode2 = 0 ;
45085 PyObject * obj0 = 0 ;
45086 PyObject * obj1 = 0 ;
45087 char * kwnames[] = {
45088 (char *) "self",(char *) "ratio", NULL
45089 };
45090
45091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45093 if (!SWIG_IsOK(res1)) {
45094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45095 }
45096 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45097 ecode2 = SWIG_AsVal_float(obj1, &val2);
45098 if (!SWIG_IsOK(ecode2)) {
45099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45100 }
45101 arg2 = static_cast< float >(val2);
45102 {
45103 PyThreadState* __tstate = wxPyBeginAllowThreads();
45104 (arg1)->SetRatio(arg2);
45105 wxPyEndAllowThreads(__tstate);
45106 if (PyErr_Occurred()) SWIG_fail;
45107 }
45108 resultobj = SWIG_Py_Void();
45109 return resultobj;
45110 fail:
45111 return NULL;
45112 }
45113
45114
45115 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45116 PyObject *resultobj = 0;
45117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45118 float result;
45119 void *argp1 = 0 ;
45120 int res1 = 0 ;
45121 PyObject *swig_obj[1] ;
45122
45123 if (!args) SWIG_fail;
45124 swig_obj[0] = args;
45125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45126 if (!SWIG_IsOK(res1)) {
45127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45128 }
45129 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45130 {
45131 PyThreadState* __tstate = wxPyBeginAllowThreads();
45132 result = (float)(arg1)->GetRatio();
45133 wxPyEndAllowThreads(__tstate);
45134 if (PyErr_Occurred()) SWIG_fail;
45135 }
45136 resultobj = SWIG_From_float(static_cast< float >(result));
45137 return resultobj;
45138 fail:
45139 return NULL;
45140 }
45141
45142
45143 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45144 PyObject *resultobj = 0;
45145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45146 wxRect result;
45147 void *argp1 = 0 ;
45148 int res1 = 0 ;
45149 PyObject *swig_obj[1] ;
45150
45151 if (!args) SWIG_fail;
45152 swig_obj[0] = args;
45153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45154 if (!SWIG_IsOK(res1)) {
45155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45156 }
45157 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45158 {
45159 PyThreadState* __tstate = wxPyBeginAllowThreads();
45160 result = (arg1)->GetRect();
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45172 PyObject *resultobj = 0;
45173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45174 bool result;
45175 void *argp1 = 0 ;
45176 int res1 = 0 ;
45177 PyObject *swig_obj[1] ;
45178
45179 if (!args) SWIG_fail;
45180 swig_obj[0] = args;
45181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45182 if (!SWIG_IsOK(res1)) {
45183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45184 }
45185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45186 {
45187 PyThreadState* __tstate = wxPyBeginAllowThreads();
45188 result = (bool)(arg1)->IsWindow();
45189 wxPyEndAllowThreads(__tstate);
45190 if (PyErr_Occurred()) SWIG_fail;
45191 }
45192 {
45193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45194 }
45195 return resultobj;
45196 fail:
45197 return NULL;
45198 }
45199
45200
45201 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45202 PyObject *resultobj = 0;
45203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45204 bool result;
45205 void *argp1 = 0 ;
45206 int res1 = 0 ;
45207 PyObject *swig_obj[1] ;
45208
45209 if (!args) SWIG_fail;
45210 swig_obj[0] = args;
45211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45212 if (!SWIG_IsOK(res1)) {
45213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45214 }
45215 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45216 {
45217 PyThreadState* __tstate = wxPyBeginAllowThreads();
45218 result = (bool)(arg1)->IsSizer();
45219 wxPyEndAllowThreads(__tstate);
45220 if (PyErr_Occurred()) SWIG_fail;
45221 }
45222 {
45223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45224 }
45225 return resultobj;
45226 fail:
45227 return NULL;
45228 }
45229
45230
45231 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45232 PyObject *resultobj = 0;
45233 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45234 bool result;
45235 void *argp1 = 0 ;
45236 int res1 = 0 ;
45237 PyObject *swig_obj[1] ;
45238
45239 if (!args) SWIG_fail;
45240 swig_obj[0] = args;
45241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45242 if (!SWIG_IsOK(res1)) {
45243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45244 }
45245 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 result = (bool)(arg1)->IsSpacer();
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 {
45253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45254 }
45255 return resultobj;
45256 fail:
45257 return NULL;
45258 }
45259
45260
45261 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45262 PyObject *resultobj = 0;
45263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45264 int arg2 ;
45265 void *argp1 = 0 ;
45266 int res1 = 0 ;
45267 int val2 ;
45268 int ecode2 = 0 ;
45269 PyObject * obj0 = 0 ;
45270 PyObject * obj1 = 0 ;
45271 char * kwnames[] = {
45272 (char *) "self",(char *) "proportion", NULL
45273 };
45274
45275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45277 if (!SWIG_IsOK(res1)) {
45278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45279 }
45280 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45281 ecode2 = SWIG_AsVal_int(obj1, &val2);
45282 if (!SWIG_IsOK(ecode2)) {
45283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45284 }
45285 arg2 = static_cast< int >(val2);
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 (arg1)->SetProportion(arg2);
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_Py_Void();
45293 return resultobj;
45294 fail:
45295 return NULL;
45296 }
45297
45298
45299 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45300 PyObject *resultobj = 0;
45301 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45302 int result;
45303 void *argp1 = 0 ;
45304 int res1 = 0 ;
45305 PyObject *swig_obj[1] ;
45306
45307 if (!args) SWIG_fail;
45308 swig_obj[0] = args;
45309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45310 if (!SWIG_IsOK(res1)) {
45311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45312 }
45313 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45314 {
45315 PyThreadState* __tstate = wxPyBeginAllowThreads();
45316 result = (int)(arg1)->GetProportion();
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 resultobj = SWIG_From_int(static_cast< int >(result));
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45328 PyObject *resultobj = 0;
45329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45330 int arg2 ;
45331 void *argp1 = 0 ;
45332 int res1 = 0 ;
45333 int val2 ;
45334 int ecode2 = 0 ;
45335 PyObject * obj0 = 0 ;
45336 PyObject * obj1 = 0 ;
45337 char * kwnames[] = {
45338 (char *) "self",(char *) "flag", NULL
45339 };
45340
45341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45343 if (!SWIG_IsOK(res1)) {
45344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45345 }
45346 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45347 ecode2 = SWIG_AsVal_int(obj1, &val2);
45348 if (!SWIG_IsOK(ecode2)) {
45349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45350 }
45351 arg2 = static_cast< int >(val2);
45352 {
45353 PyThreadState* __tstate = wxPyBeginAllowThreads();
45354 (arg1)->SetFlag(arg2);
45355 wxPyEndAllowThreads(__tstate);
45356 if (PyErr_Occurred()) SWIG_fail;
45357 }
45358 resultobj = SWIG_Py_Void();
45359 return resultobj;
45360 fail:
45361 return NULL;
45362 }
45363
45364
45365 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45366 PyObject *resultobj = 0;
45367 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45368 int result;
45369 void *argp1 = 0 ;
45370 int res1 = 0 ;
45371 PyObject *swig_obj[1] ;
45372
45373 if (!args) SWIG_fail;
45374 swig_obj[0] = args;
45375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45376 if (!SWIG_IsOK(res1)) {
45377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45378 }
45379 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 result = (int)(arg1)->GetFlag();
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 resultobj = SWIG_From_int(static_cast< int >(result));
45387 return resultobj;
45388 fail:
45389 return NULL;
45390 }
45391
45392
45393 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45394 PyObject *resultobj = 0;
45395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45396 int arg2 ;
45397 void *argp1 = 0 ;
45398 int res1 = 0 ;
45399 int val2 ;
45400 int ecode2 = 0 ;
45401 PyObject * obj0 = 0 ;
45402 PyObject * obj1 = 0 ;
45403 char * kwnames[] = {
45404 (char *) "self",(char *) "border", NULL
45405 };
45406
45407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45409 if (!SWIG_IsOK(res1)) {
45410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45411 }
45412 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45413 ecode2 = SWIG_AsVal_int(obj1, &val2);
45414 if (!SWIG_IsOK(ecode2)) {
45415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45416 }
45417 arg2 = static_cast< int >(val2);
45418 {
45419 PyThreadState* __tstate = wxPyBeginAllowThreads();
45420 (arg1)->SetBorder(arg2);
45421 wxPyEndAllowThreads(__tstate);
45422 if (PyErr_Occurred()) SWIG_fail;
45423 }
45424 resultobj = SWIG_Py_Void();
45425 return resultobj;
45426 fail:
45427 return NULL;
45428 }
45429
45430
45431 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45432 PyObject *resultobj = 0;
45433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45434 int result;
45435 void *argp1 = 0 ;
45436 int res1 = 0 ;
45437 PyObject *swig_obj[1] ;
45438
45439 if (!args) SWIG_fail;
45440 swig_obj[0] = args;
45441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45442 if (!SWIG_IsOK(res1)) {
45443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45444 }
45445 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45446 {
45447 PyThreadState* __tstate = wxPyBeginAllowThreads();
45448 result = (int)(arg1)->GetBorder();
45449 wxPyEndAllowThreads(__tstate);
45450 if (PyErr_Occurred()) SWIG_fail;
45451 }
45452 resultobj = SWIG_From_int(static_cast< int >(result));
45453 return resultobj;
45454 fail:
45455 return NULL;
45456 }
45457
45458
45459 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45460 PyObject *resultobj = 0;
45461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45462 wxWindow *result = 0 ;
45463 void *argp1 = 0 ;
45464 int res1 = 0 ;
45465 PyObject *swig_obj[1] ;
45466
45467 if (!args) SWIG_fail;
45468 swig_obj[0] = args;
45469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45472 }
45473 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45474 {
45475 PyThreadState* __tstate = wxPyBeginAllowThreads();
45476 result = (wxWindow *)(arg1)->GetWindow();
45477 wxPyEndAllowThreads(__tstate);
45478 if (PyErr_Occurred()) SWIG_fail;
45479 }
45480 {
45481 resultobj = wxPyMake_wxObject(result, 0);
45482 }
45483 return resultobj;
45484 fail:
45485 return NULL;
45486 }
45487
45488
45489 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45490 PyObject *resultobj = 0;
45491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45492 wxWindow *arg2 = (wxWindow *) 0 ;
45493 void *argp1 = 0 ;
45494 int res1 = 0 ;
45495 void *argp2 = 0 ;
45496 int res2 = 0 ;
45497 PyObject * obj0 = 0 ;
45498 PyObject * obj1 = 0 ;
45499 char * kwnames[] = {
45500 (char *) "self",(char *) "window", NULL
45501 };
45502
45503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45505 if (!SWIG_IsOK(res1)) {
45506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45507 }
45508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45510 if (!SWIG_IsOK(res2)) {
45511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45512 }
45513 arg2 = reinterpret_cast< wxWindow * >(argp2);
45514 {
45515 PyThreadState* __tstate = wxPyBeginAllowThreads();
45516 (arg1)->SetWindow(arg2);
45517 wxPyEndAllowThreads(__tstate);
45518 if (PyErr_Occurred()) SWIG_fail;
45519 }
45520 resultobj = SWIG_Py_Void();
45521 return resultobj;
45522 fail:
45523 return NULL;
45524 }
45525
45526
45527 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45528 PyObject *resultobj = 0;
45529 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45530 wxSizer *result = 0 ;
45531 void *argp1 = 0 ;
45532 int res1 = 0 ;
45533 PyObject *swig_obj[1] ;
45534
45535 if (!args) SWIG_fail;
45536 swig_obj[0] = args;
45537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45540 }
45541 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45542 {
45543 PyThreadState* __tstate = wxPyBeginAllowThreads();
45544 result = (wxSizer *)(arg1)->GetSizer();
45545 wxPyEndAllowThreads(__tstate);
45546 if (PyErr_Occurred()) SWIG_fail;
45547 }
45548 {
45549 resultobj = wxPyMake_wxObject(result, (bool)0);
45550 }
45551 return resultobj;
45552 fail:
45553 return NULL;
45554 }
45555
45556
45557 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45558 PyObject *resultobj = 0;
45559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45560 wxSizer *arg2 = (wxSizer *) 0 ;
45561 void *argp1 = 0 ;
45562 int res1 = 0 ;
45563 int res2 = 0 ;
45564 PyObject * obj0 = 0 ;
45565 PyObject * obj1 = 0 ;
45566 char * kwnames[] = {
45567 (char *) "self",(char *) "sizer", NULL
45568 };
45569
45570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45572 if (!SWIG_IsOK(res1)) {
45573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45574 }
45575 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45576 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45577 if (!SWIG_IsOK(res2)) {
45578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45579 }
45580 {
45581 PyThreadState* __tstate = wxPyBeginAllowThreads();
45582 (arg1)->SetSizer(arg2);
45583 wxPyEndAllowThreads(__tstate);
45584 if (PyErr_Occurred()) SWIG_fail;
45585 }
45586 resultobj = SWIG_Py_Void();
45587 return resultobj;
45588 fail:
45589 return NULL;
45590 }
45591
45592
45593 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45594 PyObject *resultobj = 0;
45595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45596 wxSize *result = 0 ;
45597 void *argp1 = 0 ;
45598 int res1 = 0 ;
45599 PyObject *swig_obj[1] ;
45600
45601 if (!args) SWIG_fail;
45602 swig_obj[0] = args;
45603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45604 if (!SWIG_IsOK(res1)) {
45605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45606 }
45607 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 {
45611 wxSize const &_result_ref = (arg1)->GetSpacer();
45612 result = (wxSize *) &_result_ref;
45613 }
45614 wxPyEndAllowThreads(__tstate);
45615 if (PyErr_Occurred()) SWIG_fail;
45616 }
45617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45618 return resultobj;
45619 fail:
45620 return NULL;
45621 }
45622
45623
45624 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45625 PyObject *resultobj = 0;
45626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45627 wxSize *arg2 = 0 ;
45628 void *argp1 = 0 ;
45629 int res1 = 0 ;
45630 wxSize temp2 ;
45631 PyObject * obj0 = 0 ;
45632 PyObject * obj1 = 0 ;
45633 char * kwnames[] = {
45634 (char *) "self",(char *) "size", NULL
45635 };
45636
45637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45639 if (!SWIG_IsOK(res1)) {
45640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45641 }
45642 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45643 {
45644 arg2 = &temp2;
45645 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45646 }
45647 {
45648 PyThreadState* __tstate = wxPyBeginAllowThreads();
45649 (arg1)->SetSpacer((wxSize const &)*arg2);
45650 wxPyEndAllowThreads(__tstate);
45651 if (PyErr_Occurred()) SWIG_fail;
45652 }
45653 resultobj = SWIG_Py_Void();
45654 return resultobj;
45655 fail:
45656 return NULL;
45657 }
45658
45659
45660 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45661 PyObject *resultobj = 0;
45662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45663 bool arg2 ;
45664 void *argp1 = 0 ;
45665 int res1 = 0 ;
45666 bool val2 ;
45667 int ecode2 = 0 ;
45668 PyObject * obj0 = 0 ;
45669 PyObject * obj1 = 0 ;
45670 char * kwnames[] = {
45671 (char *) "self",(char *) "show", NULL
45672 };
45673
45674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45678 }
45679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45681 if (!SWIG_IsOK(ecode2)) {
45682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45683 }
45684 arg2 = static_cast< bool >(val2);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 (arg1)->Show(arg2);
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 resultobj = SWIG_Py_Void();
45692 return resultobj;
45693 fail:
45694 return NULL;
45695 }
45696
45697
45698 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45699 PyObject *resultobj = 0;
45700 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45701 bool result;
45702 void *argp1 = 0 ;
45703 int res1 = 0 ;
45704 PyObject *swig_obj[1] ;
45705
45706 if (!args) SWIG_fail;
45707 swig_obj[0] = args;
45708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45709 if (!SWIG_IsOK(res1)) {
45710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45711 }
45712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45713 {
45714 PyThreadState* __tstate = wxPyBeginAllowThreads();
45715 result = (bool)(arg1)->IsShown();
45716 wxPyEndAllowThreads(__tstate);
45717 if (PyErr_Occurred()) SWIG_fail;
45718 }
45719 {
45720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45721 }
45722 return resultobj;
45723 fail:
45724 return NULL;
45725 }
45726
45727
45728 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45729 PyObject *resultobj = 0;
45730 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45731 wxPoint result;
45732 void *argp1 = 0 ;
45733 int res1 = 0 ;
45734 PyObject *swig_obj[1] ;
45735
45736 if (!args) SWIG_fail;
45737 swig_obj[0] = args;
45738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45739 if (!SWIG_IsOK(res1)) {
45740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45741 }
45742 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45743 {
45744 PyThreadState* __tstate = wxPyBeginAllowThreads();
45745 result = (arg1)->GetPosition();
45746 wxPyEndAllowThreads(__tstate);
45747 if (PyErr_Occurred()) SWIG_fail;
45748 }
45749 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45750 return resultobj;
45751 fail:
45752 return NULL;
45753 }
45754
45755
45756 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45757 PyObject *resultobj = 0;
45758 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45759 PyObject *result = 0 ;
45760 void *argp1 = 0 ;
45761 int res1 = 0 ;
45762 PyObject *swig_obj[1] ;
45763
45764 if (!args) SWIG_fail;
45765 swig_obj[0] = args;
45766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45767 if (!SWIG_IsOK(res1)) {
45768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45769 }
45770 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 resultobj = result;
45778 return resultobj;
45779 fail:
45780 return NULL;
45781 }
45782
45783
45784 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45785 PyObject *resultobj = 0;
45786 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45787 PyObject *arg2 = (PyObject *) 0 ;
45788 void *argp1 = 0 ;
45789 int res1 = 0 ;
45790 PyObject * obj0 = 0 ;
45791 PyObject * obj1 = 0 ;
45792 char * kwnames[] = {
45793 (char *) "self",(char *) "userData", NULL
45794 };
45795
45796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 arg2 = obj1;
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 wxSizerItem_SetUserData(arg1,arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = SWIG_Py_Void();
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45817 PyObject *obj;
45818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45819 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45820 return SWIG_Py_Void();
45821 }
45822
45823 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45824 return SWIG_Python_InitShadowInstance(args);
45825 }
45826
45827 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45828 PyObject *resultobj = 0;
45829 wxSizer *arg1 = (wxSizer *) 0 ;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 PyObject *swig_obj[1] ;
45833
45834 if (!args) SWIG_fail;
45835 swig_obj[0] = args;
45836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45837 if (!SWIG_IsOK(res1)) {
45838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45839 }
45840 arg1 = reinterpret_cast< wxSizer * >(argp1);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 delete arg1;
45844
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 resultobj = SWIG_Py_Void();
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxSizer *arg1 = (wxSizer *) 0 ;
45858 PyObject *arg2 = (PyObject *) 0 ;
45859 void *argp1 = 0 ;
45860 int res1 = 0 ;
45861 PyObject * obj0 = 0 ;
45862 PyObject * obj1 = 0 ;
45863 char * kwnames[] = {
45864 (char *) "self",(char *) "_self", NULL
45865 };
45866
45867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45869 if (!SWIG_IsOK(res1)) {
45870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45871 }
45872 arg1 = reinterpret_cast< wxSizer * >(argp1);
45873 arg2 = obj1;
45874 {
45875 PyThreadState* __tstate = wxPyBeginAllowThreads();
45876 wxSizer__setOORInfo(arg1,arg2);
45877 wxPyEndAllowThreads(__tstate);
45878 if (PyErr_Occurred()) SWIG_fail;
45879 }
45880 resultobj = SWIG_Py_Void();
45881 return resultobj;
45882 fail:
45883 return NULL;
45884 }
45885
45886
45887 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45888 PyObject *resultobj = 0;
45889 wxSizer *arg1 = (wxSizer *) 0 ;
45890 PyObject *arg2 = (PyObject *) 0 ;
45891 int arg3 = (int) 0 ;
45892 int arg4 = (int) 0 ;
45893 int arg5 = (int) 0 ;
45894 PyObject *arg6 = (PyObject *) NULL ;
45895 wxSizerItem *result = 0 ;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 int val3 ;
45899 int ecode3 = 0 ;
45900 int val4 ;
45901 int ecode4 = 0 ;
45902 int val5 ;
45903 int ecode5 = 0 ;
45904 PyObject * obj0 = 0 ;
45905 PyObject * obj1 = 0 ;
45906 PyObject * obj2 = 0 ;
45907 PyObject * obj3 = 0 ;
45908 PyObject * obj4 = 0 ;
45909 PyObject * obj5 = 0 ;
45910 char * kwnames[] = {
45911 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45912 };
45913
45914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45916 if (!SWIG_IsOK(res1)) {
45917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45918 }
45919 arg1 = reinterpret_cast< wxSizer * >(argp1);
45920 arg2 = obj1;
45921 if (obj2) {
45922 ecode3 = SWIG_AsVal_int(obj2, &val3);
45923 if (!SWIG_IsOK(ecode3)) {
45924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45925 }
45926 arg3 = static_cast< int >(val3);
45927 }
45928 if (obj3) {
45929 ecode4 = SWIG_AsVal_int(obj3, &val4);
45930 if (!SWIG_IsOK(ecode4)) {
45931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45932 }
45933 arg4 = static_cast< int >(val4);
45934 }
45935 if (obj4) {
45936 ecode5 = SWIG_AsVal_int(obj4, &val5);
45937 if (!SWIG_IsOK(ecode5)) {
45938 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45939 }
45940 arg5 = static_cast< int >(val5);
45941 }
45942 if (obj5) {
45943 arg6 = obj5;
45944 }
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45959 PyObject *resultobj = 0;
45960 wxSizer *arg1 = (wxSizer *) 0 ;
45961 int arg2 ;
45962 PyObject *arg3 = (PyObject *) 0 ;
45963 int arg4 = (int) 0 ;
45964 int arg5 = (int) 0 ;
45965 int arg6 = (int) 0 ;
45966 PyObject *arg7 = (PyObject *) NULL ;
45967 wxSizerItem *result = 0 ;
45968 void *argp1 = 0 ;
45969 int res1 = 0 ;
45970 int val2 ;
45971 int ecode2 = 0 ;
45972 int val4 ;
45973 int ecode4 = 0 ;
45974 int val5 ;
45975 int ecode5 = 0 ;
45976 int val6 ;
45977 int ecode6 = 0 ;
45978 PyObject * obj0 = 0 ;
45979 PyObject * obj1 = 0 ;
45980 PyObject * obj2 = 0 ;
45981 PyObject * obj3 = 0 ;
45982 PyObject * obj4 = 0 ;
45983 PyObject * obj5 = 0 ;
45984 PyObject * obj6 = 0 ;
45985 char * kwnames[] = {
45986 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45987 };
45988
45989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45991 if (!SWIG_IsOK(res1)) {
45992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
45993 }
45994 arg1 = reinterpret_cast< wxSizer * >(argp1);
45995 ecode2 = SWIG_AsVal_int(obj1, &val2);
45996 if (!SWIG_IsOK(ecode2)) {
45997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
45998 }
45999 arg2 = static_cast< int >(val2);
46000 arg3 = obj2;
46001 if (obj3) {
46002 ecode4 = SWIG_AsVal_int(obj3, &val4);
46003 if (!SWIG_IsOK(ecode4)) {
46004 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46005 }
46006 arg4 = static_cast< int >(val4);
46007 }
46008 if (obj4) {
46009 ecode5 = SWIG_AsVal_int(obj4, &val5);
46010 if (!SWIG_IsOK(ecode5)) {
46011 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46012 }
46013 arg5 = static_cast< int >(val5);
46014 }
46015 if (obj5) {
46016 ecode6 = SWIG_AsVal_int(obj5, &val6);
46017 if (!SWIG_IsOK(ecode6)) {
46018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46019 }
46020 arg6 = static_cast< int >(val6);
46021 }
46022 if (obj6) {
46023 arg7 = obj6;
46024 }
46025 {
46026 PyThreadState* __tstate = wxPyBeginAllowThreads();
46027 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46028 wxPyEndAllowThreads(__tstate);
46029 if (PyErr_Occurred()) SWIG_fail;
46030 }
46031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46039 PyObject *resultobj = 0;
46040 wxSizer *arg1 = (wxSizer *) 0 ;
46041 PyObject *arg2 = (PyObject *) 0 ;
46042 int arg3 = (int) 0 ;
46043 int arg4 = (int) 0 ;
46044 int arg5 = (int) 0 ;
46045 PyObject *arg6 = (PyObject *) NULL ;
46046 wxSizerItem *result = 0 ;
46047 void *argp1 = 0 ;
46048 int res1 = 0 ;
46049 int val3 ;
46050 int ecode3 = 0 ;
46051 int val4 ;
46052 int ecode4 = 0 ;
46053 int val5 ;
46054 int ecode5 = 0 ;
46055 PyObject * obj0 = 0 ;
46056 PyObject * obj1 = 0 ;
46057 PyObject * obj2 = 0 ;
46058 PyObject * obj3 = 0 ;
46059 PyObject * obj4 = 0 ;
46060 PyObject * obj5 = 0 ;
46061 char * kwnames[] = {
46062 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46063 };
46064
46065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46067 if (!SWIG_IsOK(res1)) {
46068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46069 }
46070 arg1 = reinterpret_cast< wxSizer * >(argp1);
46071 arg2 = obj1;
46072 if (obj2) {
46073 ecode3 = SWIG_AsVal_int(obj2, &val3);
46074 if (!SWIG_IsOK(ecode3)) {
46075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46076 }
46077 arg3 = static_cast< int >(val3);
46078 }
46079 if (obj3) {
46080 ecode4 = SWIG_AsVal_int(obj3, &val4);
46081 if (!SWIG_IsOK(ecode4)) {
46082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46083 }
46084 arg4 = static_cast< int >(val4);
46085 }
46086 if (obj4) {
46087 ecode5 = SWIG_AsVal_int(obj4, &val5);
46088 if (!SWIG_IsOK(ecode5)) {
46089 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46090 }
46091 arg5 = static_cast< int >(val5);
46092 }
46093 if (obj5) {
46094 arg6 = obj5;
46095 }
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46099 wxPyEndAllowThreads(__tstate);
46100 if (PyErr_Occurred()) SWIG_fail;
46101 }
46102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46103 return resultobj;
46104 fail:
46105 return NULL;
46106 }
46107
46108
46109 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46110 PyObject *resultobj = 0;
46111 wxSizer *arg1 = (wxSizer *) 0 ;
46112 PyObject *arg2 = (PyObject *) 0 ;
46113 bool result;
46114 void *argp1 = 0 ;
46115 int res1 = 0 ;
46116 PyObject * obj0 = 0 ;
46117 PyObject * obj1 = 0 ;
46118 char * kwnames[] = {
46119 (char *) "self",(char *) "item", NULL
46120 };
46121
46122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46126 }
46127 arg1 = reinterpret_cast< wxSizer * >(argp1);
46128 arg2 = obj1;
46129 {
46130 PyThreadState* __tstate = wxPyBeginAllowThreads();
46131 result = (bool)wxSizer_Remove(arg1,arg2);
46132 wxPyEndAllowThreads(__tstate);
46133 if (PyErr_Occurred()) SWIG_fail;
46134 }
46135 {
46136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46137 }
46138 return resultobj;
46139 fail:
46140 return NULL;
46141 }
46142
46143
46144 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46145 PyObject *resultobj = 0;
46146 wxSizer *arg1 = (wxSizer *) 0 ;
46147 PyObject *arg2 = (PyObject *) 0 ;
46148 bool result;
46149 void *argp1 = 0 ;
46150 int res1 = 0 ;
46151 PyObject * obj0 = 0 ;
46152 PyObject * obj1 = 0 ;
46153 char * kwnames[] = {
46154 (char *) "self",(char *) "item", NULL
46155 };
46156
46157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46159 if (!SWIG_IsOK(res1)) {
46160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46161 }
46162 arg1 = reinterpret_cast< wxSizer * >(argp1);
46163 arg2 = obj1;
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 result = (bool)wxSizer_Detach(arg1,arg2);
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 {
46171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46172 }
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46180 PyObject *resultobj = 0;
46181 wxSizer *arg1 = (wxSizer *) 0 ;
46182 PyObject *arg2 = (PyObject *) 0 ;
46183 wxSizerItem *result = 0 ;
46184 void *argp1 = 0 ;
46185 int res1 = 0 ;
46186 PyObject * obj0 = 0 ;
46187 PyObject * obj1 = 0 ;
46188 char * kwnames[] = {
46189 (char *) "self",(char *) "item", NULL
46190 };
46191
46192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46194 if (!SWIG_IsOK(res1)) {
46195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46196 }
46197 arg1 = reinterpret_cast< wxSizer * >(argp1);
46198 arg2 = obj1;
46199 {
46200 PyThreadState* __tstate = wxPyBeginAllowThreads();
46201 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46202 wxPyEndAllowThreads(__tstate);
46203 if (PyErr_Occurred()) SWIG_fail;
46204 }
46205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46206 return resultobj;
46207 fail:
46208 return NULL;
46209 }
46210
46211
46212 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46213 PyObject *resultobj = 0;
46214 wxSizer *arg1 = (wxSizer *) 0 ;
46215 PyObject *arg2 = (PyObject *) 0 ;
46216 wxSize *arg3 = 0 ;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 wxSize temp3 ;
46220 PyObject * obj0 = 0 ;
46221 PyObject * obj1 = 0 ;
46222 PyObject * obj2 = 0 ;
46223 char * kwnames[] = {
46224 (char *) "self",(char *) "item",(char *) "size", NULL
46225 };
46226
46227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46229 if (!SWIG_IsOK(res1)) {
46230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46231 }
46232 arg1 = reinterpret_cast< wxSizer * >(argp1);
46233 arg2 = obj1;
46234 {
46235 arg3 = &temp3;
46236 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46237 }
46238 {
46239 PyThreadState* __tstate = wxPyBeginAllowThreads();
46240 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46241 wxPyEndAllowThreads(__tstate);
46242 if (PyErr_Occurred()) SWIG_fail;
46243 }
46244 resultobj = SWIG_Py_Void();
46245 return resultobj;
46246 fail:
46247 return NULL;
46248 }
46249
46250
46251 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46252 PyObject *resultobj = 0;
46253 wxSizer *arg1 = (wxSizer *) 0 ;
46254 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46255 wxSizerItem *result = 0 ;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 int res2 = 0 ;
46259 PyObject * obj0 = 0 ;
46260 PyObject * obj1 = 0 ;
46261 char * kwnames[] = {
46262 (char *) "self",(char *) "item", NULL
46263 };
46264
46265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46267 if (!SWIG_IsOK(res1)) {
46268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46269 }
46270 arg1 = reinterpret_cast< wxSizer * >(argp1);
46271 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46272 if (!SWIG_IsOK(res2)) {
46273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46274 }
46275 {
46276 PyThreadState* __tstate = wxPyBeginAllowThreads();
46277 result = (wxSizerItem *)(arg1)->Add(arg2);
46278 wxPyEndAllowThreads(__tstate);
46279 if (PyErr_Occurred()) SWIG_fail;
46280 }
46281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46282 return resultobj;
46283 fail:
46284 return NULL;
46285 }
46286
46287
46288 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46289 PyObject *resultobj = 0;
46290 wxSizer *arg1 = (wxSizer *) 0 ;
46291 size_t arg2 ;
46292 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46293 wxSizerItem *result = 0 ;
46294 void *argp1 = 0 ;
46295 int res1 = 0 ;
46296 size_t val2 ;
46297 int ecode2 = 0 ;
46298 int res3 = 0 ;
46299 PyObject * obj0 = 0 ;
46300 PyObject * obj1 = 0 ;
46301 PyObject * obj2 = 0 ;
46302 char * kwnames[] = {
46303 (char *) "self",(char *) "index",(char *) "item", NULL
46304 };
46305
46306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46308 if (!SWIG_IsOK(res1)) {
46309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46310 }
46311 arg1 = reinterpret_cast< wxSizer * >(argp1);
46312 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46313 if (!SWIG_IsOK(ecode2)) {
46314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46315 }
46316 arg2 = static_cast< size_t >(val2);
46317 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46318 if (!SWIG_IsOK(res3)) {
46319 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46320 }
46321 {
46322 PyThreadState* __tstate = wxPyBeginAllowThreads();
46323 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46324 wxPyEndAllowThreads(__tstate);
46325 if (PyErr_Occurred()) SWIG_fail;
46326 }
46327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46328 return resultobj;
46329 fail:
46330 return NULL;
46331 }
46332
46333
46334 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46335 PyObject *resultobj = 0;
46336 wxSizer *arg1 = (wxSizer *) 0 ;
46337 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46338 wxSizerItem *result = 0 ;
46339 void *argp1 = 0 ;
46340 int res1 = 0 ;
46341 int res2 = 0 ;
46342 PyObject * obj0 = 0 ;
46343 PyObject * obj1 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "item", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizer * >(argp1);
46354 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46355 if (!SWIG_IsOK(res2)) {
46356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46357 }
46358 {
46359 PyThreadState* __tstate = wxPyBeginAllowThreads();
46360 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46361 wxPyEndAllowThreads(__tstate);
46362 if (PyErr_Occurred()) SWIG_fail;
46363 }
46364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46365 return resultobj;
46366 fail:
46367 return NULL;
46368 }
46369
46370
46371 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46372 PyObject *resultobj = 0;
46373 wxSizer *arg1 = (wxSizer *) 0 ;
46374 int arg2 ;
46375 int arg3 ;
46376 int arg4 ;
46377 int arg5 ;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 int val2 ;
46381 int ecode2 = 0 ;
46382 int val3 ;
46383 int ecode3 = 0 ;
46384 int val4 ;
46385 int ecode4 = 0 ;
46386 int val5 ;
46387 int ecode5 = 0 ;
46388 PyObject * obj0 = 0 ;
46389 PyObject * obj1 = 0 ;
46390 PyObject * obj2 = 0 ;
46391 PyObject * obj3 = 0 ;
46392 PyObject * obj4 = 0 ;
46393 char * kwnames[] = {
46394 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46395 };
46396
46397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46399 if (!SWIG_IsOK(res1)) {
46400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46401 }
46402 arg1 = reinterpret_cast< wxSizer * >(argp1);
46403 ecode2 = SWIG_AsVal_int(obj1, &val2);
46404 if (!SWIG_IsOK(ecode2)) {
46405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46406 }
46407 arg2 = static_cast< int >(val2);
46408 ecode3 = SWIG_AsVal_int(obj2, &val3);
46409 if (!SWIG_IsOK(ecode3)) {
46410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46411 }
46412 arg3 = static_cast< int >(val3);
46413 ecode4 = SWIG_AsVal_int(obj3, &val4);
46414 if (!SWIG_IsOK(ecode4)) {
46415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46416 }
46417 arg4 = static_cast< int >(val4);
46418 ecode5 = SWIG_AsVal_int(obj4, &val5);
46419 if (!SWIG_IsOK(ecode5)) {
46420 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46421 }
46422 arg5 = static_cast< int >(val5);
46423 {
46424 PyThreadState* __tstate = wxPyBeginAllowThreads();
46425 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46426 wxPyEndAllowThreads(__tstate);
46427 if (PyErr_Occurred()) SWIG_fail;
46428 }
46429 resultobj = SWIG_Py_Void();
46430 return resultobj;
46431 fail:
46432 return NULL;
46433 }
46434
46435
46436 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46437 PyObject *resultobj = 0;
46438 wxSizer *arg1 = (wxSizer *) 0 ;
46439 wxSize *arg2 = 0 ;
46440 void *argp1 = 0 ;
46441 int res1 = 0 ;
46442 wxSize temp2 ;
46443 PyObject * obj0 = 0 ;
46444 PyObject * obj1 = 0 ;
46445 char * kwnames[] = {
46446 (char *) "self",(char *) "size", NULL
46447 };
46448
46449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46451 if (!SWIG_IsOK(res1)) {
46452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46453 }
46454 arg1 = reinterpret_cast< wxSizer * >(argp1);
46455 {
46456 arg2 = &temp2;
46457 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46458 }
46459 {
46460 PyThreadState* __tstate = wxPyBeginAllowThreads();
46461 (arg1)->SetMinSize((wxSize const &)*arg2);
46462 wxPyEndAllowThreads(__tstate);
46463 if (PyErr_Occurred()) SWIG_fail;
46464 }
46465 resultobj = SWIG_Py_Void();
46466 return resultobj;
46467 fail:
46468 return NULL;
46469 }
46470
46471
46472 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46473 PyObject *resultobj = 0;
46474 wxSizer *arg1 = (wxSizer *) 0 ;
46475 wxSize result;
46476 void *argp1 = 0 ;
46477 int res1 = 0 ;
46478 PyObject *swig_obj[1] ;
46479
46480 if (!args) SWIG_fail;
46481 swig_obj[0] = args;
46482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46485 }
46486 arg1 = reinterpret_cast< wxSizer * >(argp1);
46487 {
46488 PyThreadState* __tstate = wxPyBeginAllowThreads();
46489 result = (arg1)->GetSize();
46490 wxPyEndAllowThreads(__tstate);
46491 if (PyErr_Occurred()) SWIG_fail;
46492 }
46493 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46494 return resultobj;
46495 fail:
46496 return NULL;
46497 }
46498
46499
46500 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46501 PyObject *resultobj = 0;
46502 wxSizer *arg1 = (wxSizer *) 0 ;
46503 wxPoint result;
46504 void *argp1 = 0 ;
46505 int res1 = 0 ;
46506 PyObject *swig_obj[1] ;
46507
46508 if (!args) SWIG_fail;
46509 swig_obj[0] = args;
46510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46511 if (!SWIG_IsOK(res1)) {
46512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46513 }
46514 arg1 = reinterpret_cast< wxSizer * >(argp1);
46515 {
46516 PyThreadState* __tstate = wxPyBeginAllowThreads();
46517 result = (arg1)->GetPosition();
46518 wxPyEndAllowThreads(__tstate);
46519 if (PyErr_Occurred()) SWIG_fail;
46520 }
46521 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46522 return resultobj;
46523 fail:
46524 return NULL;
46525 }
46526
46527
46528 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46529 PyObject *resultobj = 0;
46530 wxSizer *arg1 = (wxSizer *) 0 ;
46531 wxSize result;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 PyObject *swig_obj[1] ;
46535
46536 if (!args) SWIG_fail;
46537 swig_obj[0] = args;
46538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46541 }
46542 arg1 = reinterpret_cast< wxSizer * >(argp1);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 result = (arg1)->GetMinSize();
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46557 PyObject *resultobj = 0;
46558 wxSizer *arg1 = (wxSizer *) 0 ;
46559 void *argp1 = 0 ;
46560 int res1 = 0 ;
46561 PyObject *swig_obj[1] ;
46562
46563 if (!args) SWIG_fail;
46564 swig_obj[0] = args;
46565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46566 if (!SWIG_IsOK(res1)) {
46567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46568 }
46569 arg1 = reinterpret_cast< wxSizer * >(argp1);
46570 {
46571 PyThreadState* __tstate = wxPyBeginAllowThreads();
46572 (arg1)->RecalcSizes();
46573 wxPyEndAllowThreads(__tstate);
46574 if (PyErr_Occurred()) SWIG_fail;
46575 }
46576 resultobj = SWIG_Py_Void();
46577 return resultobj;
46578 fail:
46579 return NULL;
46580 }
46581
46582
46583 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46584 PyObject *resultobj = 0;
46585 wxSizer *arg1 = (wxSizer *) 0 ;
46586 wxSize result;
46587 void *argp1 = 0 ;
46588 int res1 = 0 ;
46589 PyObject *swig_obj[1] ;
46590
46591 if (!args) SWIG_fail;
46592 swig_obj[0] = args;
46593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 {
46599 PyThreadState* __tstate = wxPyBeginAllowThreads();
46600 result = (arg1)->CalcMin();
46601 wxPyEndAllowThreads(__tstate);
46602 if (PyErr_Occurred()) SWIG_fail;
46603 }
46604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46605 return resultobj;
46606 fail:
46607 return NULL;
46608 }
46609
46610
46611 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46612 PyObject *resultobj = 0;
46613 wxSizer *arg1 = (wxSizer *) 0 ;
46614 void *argp1 = 0 ;
46615 int res1 = 0 ;
46616 PyObject *swig_obj[1] ;
46617
46618 if (!args) SWIG_fail;
46619 swig_obj[0] = args;
46620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46621 if (!SWIG_IsOK(res1)) {
46622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46623 }
46624 arg1 = reinterpret_cast< wxSizer * >(argp1);
46625 {
46626 PyThreadState* __tstate = wxPyBeginAllowThreads();
46627 (arg1)->Layout();
46628 wxPyEndAllowThreads(__tstate);
46629 if (PyErr_Occurred()) SWIG_fail;
46630 }
46631 resultobj = SWIG_Py_Void();
46632 return resultobj;
46633 fail:
46634 return NULL;
46635 }
46636
46637
46638 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46639 PyObject *resultobj = 0;
46640 wxSizer *arg1 = (wxSizer *) 0 ;
46641 wxWindow *arg2 = (wxWindow *) 0 ;
46642 wxSize result;
46643 void *argp1 = 0 ;
46644 int res1 = 0 ;
46645 void *argp2 = 0 ;
46646 int res2 = 0 ;
46647 PyObject * obj0 = 0 ;
46648 PyObject * obj1 = 0 ;
46649 char * kwnames[] = {
46650 (char *) "self",(char *) "window", NULL
46651 };
46652
46653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46655 if (!SWIG_IsOK(res1)) {
46656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46657 }
46658 arg1 = reinterpret_cast< wxSizer * >(argp1);
46659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46660 if (!SWIG_IsOK(res2)) {
46661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46662 }
46663 arg2 = reinterpret_cast< wxWindow * >(argp2);
46664 {
46665 PyThreadState* __tstate = wxPyBeginAllowThreads();
46666 result = (arg1)->Fit(arg2);
46667 wxPyEndAllowThreads(__tstate);
46668 if (PyErr_Occurred()) SWIG_fail;
46669 }
46670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46671 return resultobj;
46672 fail:
46673 return NULL;
46674 }
46675
46676
46677 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46678 PyObject *resultobj = 0;
46679 wxSizer *arg1 = (wxSizer *) 0 ;
46680 wxWindow *arg2 = (wxWindow *) 0 ;
46681 void *argp1 = 0 ;
46682 int res1 = 0 ;
46683 void *argp2 = 0 ;
46684 int res2 = 0 ;
46685 PyObject * obj0 = 0 ;
46686 PyObject * obj1 = 0 ;
46687 char * kwnames[] = {
46688 (char *) "self",(char *) "window", NULL
46689 };
46690
46691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46695 }
46696 arg1 = reinterpret_cast< wxSizer * >(argp1);
46697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46698 if (!SWIG_IsOK(res2)) {
46699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46700 }
46701 arg2 = reinterpret_cast< wxWindow * >(argp2);
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
46704 (arg1)->FitInside(arg2);
46705 wxPyEndAllowThreads(__tstate);
46706 if (PyErr_Occurred()) SWIG_fail;
46707 }
46708 resultobj = SWIG_Py_Void();
46709 return resultobj;
46710 fail:
46711 return NULL;
46712 }
46713
46714
46715 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46716 PyObject *resultobj = 0;
46717 wxSizer *arg1 = (wxSizer *) 0 ;
46718 wxWindow *arg2 = (wxWindow *) 0 ;
46719 void *argp1 = 0 ;
46720 int res1 = 0 ;
46721 void *argp2 = 0 ;
46722 int res2 = 0 ;
46723 PyObject * obj0 = 0 ;
46724 PyObject * obj1 = 0 ;
46725 char * kwnames[] = {
46726 (char *) "self",(char *) "window", NULL
46727 };
46728
46729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46731 if (!SWIG_IsOK(res1)) {
46732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46733 }
46734 arg1 = reinterpret_cast< wxSizer * >(argp1);
46735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46736 if (!SWIG_IsOK(res2)) {
46737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46738 }
46739 arg2 = reinterpret_cast< wxWindow * >(argp2);
46740 {
46741 PyThreadState* __tstate = wxPyBeginAllowThreads();
46742 (arg1)->SetSizeHints(arg2);
46743 wxPyEndAllowThreads(__tstate);
46744 if (PyErr_Occurred()) SWIG_fail;
46745 }
46746 resultobj = SWIG_Py_Void();
46747 return resultobj;
46748 fail:
46749 return NULL;
46750 }
46751
46752
46753 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46754 PyObject *resultobj = 0;
46755 wxSizer *arg1 = (wxSizer *) 0 ;
46756 wxWindow *arg2 = (wxWindow *) 0 ;
46757 void *argp1 = 0 ;
46758 int res1 = 0 ;
46759 void *argp2 = 0 ;
46760 int res2 = 0 ;
46761 PyObject * obj0 = 0 ;
46762 PyObject * obj1 = 0 ;
46763 char * kwnames[] = {
46764 (char *) "self",(char *) "window", NULL
46765 };
46766
46767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46769 if (!SWIG_IsOK(res1)) {
46770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46771 }
46772 arg1 = reinterpret_cast< wxSizer * >(argp1);
46773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46774 if (!SWIG_IsOK(res2)) {
46775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46776 }
46777 arg2 = reinterpret_cast< wxWindow * >(argp2);
46778 {
46779 PyThreadState* __tstate = wxPyBeginAllowThreads();
46780 (arg1)->SetVirtualSizeHints(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_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46792 PyObject *resultobj = 0;
46793 wxSizer *arg1 = (wxSizer *) 0 ;
46794 bool arg2 = (bool) false ;
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 *) "deleteWindows", NULL
46803 };
46804
46805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46809 }
46810 arg1 = reinterpret_cast< wxSizer * >(argp1);
46811 if (obj1) {
46812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46813 if (!SWIG_IsOK(ecode2)) {
46814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46815 }
46816 arg2 = static_cast< bool >(val2);
46817 }
46818 {
46819 PyThreadState* __tstate = wxPyBeginAllowThreads();
46820 (arg1)->Clear(arg2);
46821 wxPyEndAllowThreads(__tstate);
46822 if (PyErr_Occurred()) SWIG_fail;
46823 }
46824 resultobj = SWIG_Py_Void();
46825 return resultobj;
46826 fail:
46827 return NULL;
46828 }
46829
46830
46831 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46832 PyObject *resultobj = 0;
46833 wxSizer *arg1 = (wxSizer *) 0 ;
46834 void *argp1 = 0 ;
46835 int res1 = 0 ;
46836 PyObject *swig_obj[1] ;
46837
46838 if (!args) SWIG_fail;
46839 swig_obj[0] = args;
46840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46843 }
46844 arg1 = reinterpret_cast< wxSizer * >(argp1);
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 (arg1)->DeleteWindows();
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 resultobj = SWIG_Py_Void();
46852 return resultobj;
46853 fail:
46854 return NULL;
46855 }
46856
46857
46858 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46859 PyObject *resultobj = 0;
46860 wxSizer *arg1 = (wxSizer *) 0 ;
46861 PyObject *result = 0 ;
46862 void *argp1 = 0 ;
46863 int res1 = 0 ;
46864 PyObject *swig_obj[1] ;
46865
46866 if (!args) SWIG_fail;
46867 swig_obj[0] = args;
46868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46869 if (!SWIG_IsOK(res1)) {
46870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46871 }
46872 arg1 = reinterpret_cast< wxSizer * >(argp1);
46873 {
46874 PyThreadState* __tstate = wxPyBeginAllowThreads();
46875 result = (PyObject *)wxSizer_GetChildren(arg1);
46876 wxPyEndAllowThreads(__tstate);
46877 if (PyErr_Occurred()) SWIG_fail;
46878 }
46879 resultobj = result;
46880 return resultobj;
46881 fail:
46882 return NULL;
46883 }
46884
46885
46886 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46887 PyObject *resultobj = 0;
46888 wxSizer *arg1 = (wxSizer *) 0 ;
46889 PyObject *arg2 = (PyObject *) 0 ;
46890 bool arg3 = (bool) true ;
46891 bool arg4 = (bool) false ;
46892 bool result;
46893 void *argp1 = 0 ;
46894 int res1 = 0 ;
46895 bool val3 ;
46896 int ecode3 = 0 ;
46897 bool val4 ;
46898 int ecode4 = 0 ;
46899 PyObject * obj0 = 0 ;
46900 PyObject * obj1 = 0 ;
46901 PyObject * obj2 = 0 ;
46902 PyObject * obj3 = 0 ;
46903 char * kwnames[] = {
46904 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46905 };
46906
46907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46909 if (!SWIG_IsOK(res1)) {
46910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46911 }
46912 arg1 = reinterpret_cast< wxSizer * >(argp1);
46913 arg2 = obj1;
46914 if (obj2) {
46915 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46916 if (!SWIG_IsOK(ecode3)) {
46917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46918 }
46919 arg3 = static_cast< bool >(val3);
46920 }
46921 if (obj3) {
46922 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46923 if (!SWIG_IsOK(ecode4)) {
46924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46925 }
46926 arg4 = static_cast< bool >(val4);
46927 }
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46931 wxPyEndAllowThreads(__tstate);
46932 if (PyErr_Occurred()) SWIG_fail;
46933 }
46934 {
46935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46936 }
46937 return resultobj;
46938 fail:
46939 return NULL;
46940 }
46941
46942
46943 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46944 PyObject *resultobj = 0;
46945 wxSizer *arg1 = (wxSizer *) 0 ;
46946 PyObject *arg2 = (PyObject *) 0 ;
46947 bool result;
46948 void *argp1 = 0 ;
46949 int res1 = 0 ;
46950 PyObject * obj0 = 0 ;
46951 PyObject * obj1 = 0 ;
46952 char * kwnames[] = {
46953 (char *) "self",(char *) "item", NULL
46954 };
46955
46956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46960 }
46961 arg1 = reinterpret_cast< wxSizer * >(argp1);
46962 arg2 = obj1;
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 result = (bool)wxSizer_IsShown(arg1,arg2);
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 {
46970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46971 }
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46979 PyObject *resultobj = 0;
46980 wxSizer *arg1 = (wxSizer *) 0 ;
46981 bool arg2 ;
46982 void *argp1 = 0 ;
46983 int res1 = 0 ;
46984 bool val2 ;
46985 int ecode2 = 0 ;
46986 PyObject * obj0 = 0 ;
46987 PyObject * obj1 = 0 ;
46988 char * kwnames[] = {
46989 (char *) "self",(char *) "show", NULL
46990 };
46991
46992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
46993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
46996 }
46997 arg1 = reinterpret_cast< wxSizer * >(argp1);
46998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46999 if (!SWIG_IsOK(ecode2)) {
47000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47001 }
47002 arg2 = static_cast< bool >(val2);
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 (arg1)->ShowItems(arg2);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_Py_Void();
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47017 PyObject *obj;
47018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47019 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47020 return SWIG_Py_Void();
47021 }
47022
47023 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47024 PyObject *resultobj = 0;
47025 wxPySizer *result = 0 ;
47026
47027 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47028 {
47029 PyThreadState* __tstate = wxPyBeginAllowThreads();
47030 result = (wxPySizer *)new wxPySizer();
47031 wxPyEndAllowThreads(__tstate);
47032 if (PyErr_Occurred()) SWIG_fail;
47033 }
47034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47035 return resultobj;
47036 fail:
47037 return NULL;
47038 }
47039
47040
47041 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47042 PyObject *resultobj = 0;
47043 wxPySizer *arg1 = (wxPySizer *) 0 ;
47044 PyObject *arg2 = (PyObject *) 0 ;
47045 PyObject *arg3 = (PyObject *) 0 ;
47046 void *argp1 = 0 ;
47047 int res1 = 0 ;
47048 PyObject * obj0 = 0 ;
47049 PyObject * obj1 = 0 ;
47050 PyObject * obj2 = 0 ;
47051 char * kwnames[] = {
47052 (char *) "self",(char *) "self",(char *) "_class", NULL
47053 };
47054
47055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47057 if (!SWIG_IsOK(res1)) {
47058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47059 }
47060 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47061 arg2 = obj1;
47062 arg3 = obj2;
47063 {
47064 PyThreadState* __tstate = wxPyBeginAllowThreads();
47065 (arg1)->_setCallbackInfo(arg2,arg3);
47066 wxPyEndAllowThreads(__tstate);
47067 if (PyErr_Occurred()) SWIG_fail;
47068 }
47069 resultobj = SWIG_Py_Void();
47070 return resultobj;
47071 fail:
47072 return NULL;
47073 }
47074
47075
47076 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47077 PyObject *obj;
47078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47080 return SWIG_Py_Void();
47081 }
47082
47083 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47084 return SWIG_Python_InitShadowInstance(args);
47085 }
47086
47087 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47088 PyObject *resultobj = 0;
47089 int arg1 = (int) wxHORIZONTAL ;
47090 wxBoxSizer *result = 0 ;
47091 int val1 ;
47092 int ecode1 = 0 ;
47093 PyObject * obj0 = 0 ;
47094 char * kwnames[] = {
47095 (char *) "orient", NULL
47096 };
47097
47098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47099 if (obj0) {
47100 ecode1 = SWIG_AsVal_int(obj0, &val1);
47101 if (!SWIG_IsOK(ecode1)) {
47102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47103 }
47104 arg1 = static_cast< int >(val1);
47105 }
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47120 PyObject *resultobj = 0;
47121 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47122 int result;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 PyObject *swig_obj[1] ;
47126
47127 if (!args) SWIG_fail;
47128 swig_obj[0] = args;
47129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47130 if (!SWIG_IsOK(res1)) {
47131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47132 }
47133 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 result = (int)(arg1)->GetOrientation();
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 resultobj = SWIG_From_int(static_cast< int >(result));
47141 return resultobj;
47142 fail:
47143 return NULL;
47144 }
47145
47146
47147 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47148 PyObject *resultobj = 0;
47149 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47150 int arg2 ;
47151 void *argp1 = 0 ;
47152 int res1 = 0 ;
47153 int val2 ;
47154 int ecode2 = 0 ;
47155 PyObject * obj0 = 0 ;
47156 PyObject * obj1 = 0 ;
47157 char * kwnames[] = {
47158 (char *) "self",(char *) "orient", NULL
47159 };
47160
47161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47163 if (!SWIG_IsOK(res1)) {
47164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47165 }
47166 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47167 ecode2 = SWIG_AsVal_int(obj1, &val2);
47168 if (!SWIG_IsOK(ecode2)) {
47169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47170 }
47171 arg2 = static_cast< int >(val2);
47172 {
47173 PyThreadState* __tstate = wxPyBeginAllowThreads();
47174 (arg1)->SetOrientation(arg2);
47175 wxPyEndAllowThreads(__tstate);
47176 if (PyErr_Occurred()) SWIG_fail;
47177 }
47178 resultobj = SWIG_Py_Void();
47179 return resultobj;
47180 fail:
47181 return NULL;
47182 }
47183
47184
47185 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47186 PyObject *obj;
47187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47188 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47189 return SWIG_Py_Void();
47190 }
47191
47192 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47193 return SWIG_Python_InitShadowInstance(args);
47194 }
47195
47196 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47197 PyObject *resultobj = 0;
47198 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47199 int arg2 = (int) wxHORIZONTAL ;
47200 wxStaticBoxSizer *result = 0 ;
47201 void *argp1 = 0 ;
47202 int res1 = 0 ;
47203 int val2 ;
47204 int ecode2 = 0 ;
47205 PyObject * obj0 = 0 ;
47206 PyObject * obj1 = 0 ;
47207 char * kwnames[] = {
47208 (char *) "box",(char *) "orient", NULL
47209 };
47210
47211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47213 if (!SWIG_IsOK(res1)) {
47214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47215 }
47216 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47217 if (obj1) {
47218 ecode2 = SWIG_AsVal_int(obj1, &val2);
47219 if (!SWIG_IsOK(ecode2)) {
47220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47221 }
47222 arg2 = static_cast< int >(val2);
47223 }
47224 {
47225 PyThreadState* __tstate = wxPyBeginAllowThreads();
47226 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47227 wxPyEndAllowThreads(__tstate);
47228 if (PyErr_Occurred()) SWIG_fail;
47229 }
47230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47231 return resultobj;
47232 fail:
47233 return NULL;
47234 }
47235
47236
47237 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47238 PyObject *resultobj = 0;
47239 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47240 wxStaticBox *result = 0 ;
47241 void *argp1 = 0 ;
47242 int res1 = 0 ;
47243 PyObject *swig_obj[1] ;
47244
47245 if (!args) SWIG_fail;
47246 swig_obj[0] = args;
47247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47248 if (!SWIG_IsOK(res1)) {
47249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47250 }
47251 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 result = (wxStaticBox *)(arg1)->GetStaticBox();
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 {
47259 resultobj = wxPyMake_wxObject(result, (bool)0);
47260 }
47261 return resultobj;
47262 fail:
47263 return NULL;
47264 }
47265
47266
47267 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47268 PyObject *obj;
47269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47270 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47271 return SWIG_Py_Void();
47272 }
47273
47274 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47275 return SWIG_Python_InitShadowInstance(args);
47276 }
47277
47278 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47279 PyObject *resultobj = 0;
47280 int arg1 = (int) 1 ;
47281 int arg2 = (int) 0 ;
47282 int arg3 = (int) 0 ;
47283 int arg4 = (int) 0 ;
47284 wxGridSizer *result = 0 ;
47285 int val1 ;
47286 int ecode1 = 0 ;
47287 int val2 ;
47288 int ecode2 = 0 ;
47289 int val3 ;
47290 int ecode3 = 0 ;
47291 int val4 ;
47292 int ecode4 = 0 ;
47293 PyObject * obj0 = 0 ;
47294 PyObject * obj1 = 0 ;
47295 PyObject * obj2 = 0 ;
47296 PyObject * obj3 = 0 ;
47297 char * kwnames[] = {
47298 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47299 };
47300
47301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47302 if (obj0) {
47303 ecode1 = SWIG_AsVal_int(obj0, &val1);
47304 if (!SWIG_IsOK(ecode1)) {
47305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47306 }
47307 arg1 = static_cast< int >(val1);
47308 }
47309 if (obj1) {
47310 ecode2 = SWIG_AsVal_int(obj1, &val2);
47311 if (!SWIG_IsOK(ecode2)) {
47312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47313 }
47314 arg2 = static_cast< int >(val2);
47315 }
47316 if (obj2) {
47317 ecode3 = SWIG_AsVal_int(obj2, &val3);
47318 if (!SWIG_IsOK(ecode3)) {
47319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47320 }
47321 arg3 = static_cast< int >(val3);
47322 }
47323 if (obj3) {
47324 ecode4 = SWIG_AsVal_int(obj3, &val4);
47325 if (!SWIG_IsOK(ecode4)) {
47326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47327 }
47328 arg4 = static_cast< int >(val4);
47329 }
47330 {
47331 PyThreadState* __tstate = wxPyBeginAllowThreads();
47332 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47333 wxPyEndAllowThreads(__tstate);
47334 if (PyErr_Occurred()) SWIG_fail;
47335 }
47336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47344 PyObject *resultobj = 0;
47345 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47346 int arg2 ;
47347 void *argp1 = 0 ;
47348 int res1 = 0 ;
47349 int val2 ;
47350 int ecode2 = 0 ;
47351 PyObject * obj0 = 0 ;
47352 PyObject * obj1 = 0 ;
47353 char * kwnames[] = {
47354 (char *) "self",(char *) "cols", NULL
47355 };
47356
47357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47359 if (!SWIG_IsOK(res1)) {
47360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47361 }
47362 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47363 ecode2 = SWIG_AsVal_int(obj1, &val2);
47364 if (!SWIG_IsOK(ecode2)) {
47365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47366 }
47367 arg2 = static_cast< int >(val2);
47368 {
47369 PyThreadState* __tstate = wxPyBeginAllowThreads();
47370 (arg1)->SetCols(arg2);
47371 wxPyEndAllowThreads(__tstate);
47372 if (PyErr_Occurred()) SWIG_fail;
47373 }
47374 resultobj = SWIG_Py_Void();
47375 return resultobj;
47376 fail:
47377 return NULL;
47378 }
47379
47380
47381 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47382 PyObject *resultobj = 0;
47383 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47384 int arg2 ;
47385 void *argp1 = 0 ;
47386 int res1 = 0 ;
47387 int val2 ;
47388 int ecode2 = 0 ;
47389 PyObject * obj0 = 0 ;
47390 PyObject * obj1 = 0 ;
47391 char * kwnames[] = {
47392 (char *) "self",(char *) "rows", NULL
47393 };
47394
47395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47397 if (!SWIG_IsOK(res1)) {
47398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47399 }
47400 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47401 ecode2 = SWIG_AsVal_int(obj1, &val2);
47402 if (!SWIG_IsOK(ecode2)) {
47403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47404 }
47405 arg2 = static_cast< int >(val2);
47406 {
47407 PyThreadState* __tstate = wxPyBeginAllowThreads();
47408 (arg1)->SetRows(arg2);
47409 wxPyEndAllowThreads(__tstate);
47410 if (PyErr_Occurred()) SWIG_fail;
47411 }
47412 resultobj = SWIG_Py_Void();
47413 return resultobj;
47414 fail:
47415 return NULL;
47416 }
47417
47418
47419 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47420 PyObject *resultobj = 0;
47421 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47422 int arg2 ;
47423 void *argp1 = 0 ;
47424 int res1 = 0 ;
47425 int val2 ;
47426 int ecode2 = 0 ;
47427 PyObject * obj0 = 0 ;
47428 PyObject * obj1 = 0 ;
47429 char * kwnames[] = {
47430 (char *) "self",(char *) "gap", NULL
47431 };
47432
47433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47437 }
47438 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47439 ecode2 = SWIG_AsVal_int(obj1, &val2);
47440 if (!SWIG_IsOK(ecode2)) {
47441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47442 }
47443 arg2 = static_cast< int >(val2);
47444 {
47445 PyThreadState* __tstate = wxPyBeginAllowThreads();
47446 (arg1)->SetVGap(arg2);
47447 wxPyEndAllowThreads(__tstate);
47448 if (PyErr_Occurred()) SWIG_fail;
47449 }
47450 resultobj = SWIG_Py_Void();
47451 return resultobj;
47452 fail:
47453 return NULL;
47454 }
47455
47456
47457 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47458 PyObject *resultobj = 0;
47459 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47460 int arg2 ;
47461 void *argp1 = 0 ;
47462 int res1 = 0 ;
47463 int val2 ;
47464 int ecode2 = 0 ;
47465 PyObject * obj0 = 0 ;
47466 PyObject * obj1 = 0 ;
47467 char * kwnames[] = {
47468 (char *) "self",(char *) "gap", NULL
47469 };
47470
47471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47473 if (!SWIG_IsOK(res1)) {
47474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47475 }
47476 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47477 ecode2 = SWIG_AsVal_int(obj1, &val2);
47478 if (!SWIG_IsOK(ecode2)) {
47479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47480 }
47481 arg2 = static_cast< int >(val2);
47482 {
47483 PyThreadState* __tstate = wxPyBeginAllowThreads();
47484 (arg1)->SetHGap(arg2);
47485 wxPyEndAllowThreads(__tstate);
47486 if (PyErr_Occurred()) SWIG_fail;
47487 }
47488 resultobj = SWIG_Py_Void();
47489 return resultobj;
47490 fail:
47491 return NULL;
47492 }
47493
47494
47495 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47496 PyObject *resultobj = 0;
47497 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47498 int result;
47499 void *argp1 = 0 ;
47500 int res1 = 0 ;
47501 PyObject *swig_obj[1] ;
47502
47503 if (!args) SWIG_fail;
47504 swig_obj[0] = args;
47505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47506 if (!SWIG_IsOK(res1)) {
47507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47508 }
47509 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47510 {
47511 PyThreadState* __tstate = wxPyBeginAllowThreads();
47512 result = (int)(arg1)->GetCols();
47513 wxPyEndAllowThreads(__tstate);
47514 if (PyErr_Occurred()) SWIG_fail;
47515 }
47516 resultobj = SWIG_From_int(static_cast< int >(result));
47517 return resultobj;
47518 fail:
47519 return NULL;
47520 }
47521
47522
47523 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47524 PyObject *resultobj = 0;
47525 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47526 int result;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 PyObject *swig_obj[1] ;
47530
47531 if (!args) SWIG_fail;
47532 swig_obj[0] = args;
47533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47534 if (!SWIG_IsOK(res1)) {
47535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47536 }
47537 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 result = (int)(arg1)->GetRows();
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_From_int(static_cast< int >(result));
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47552 PyObject *resultobj = 0;
47553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47554 int result;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 PyObject *swig_obj[1] ;
47558
47559 if (!args) SWIG_fail;
47560 swig_obj[0] = args;
47561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47562 if (!SWIG_IsOK(res1)) {
47563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47564 }
47565 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 result = (int)(arg1)->GetVGap();
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 resultobj = SWIG_From_int(static_cast< int >(result));
47573 return resultobj;
47574 fail:
47575 return NULL;
47576 }
47577
47578
47579 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 PyObject *resultobj = 0;
47581 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47582 int result;
47583 void *argp1 = 0 ;
47584 int res1 = 0 ;
47585 PyObject *swig_obj[1] ;
47586
47587 if (!args) SWIG_fail;
47588 swig_obj[0] = args;
47589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47590 if (!SWIG_IsOK(res1)) {
47591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47592 }
47593 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 result = (int)(arg1)->GetHGap();
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_From_int(static_cast< int >(result));
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *obj;
47609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47610 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47611 return SWIG_Py_Void();
47612 }
47613
47614 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47615 return SWIG_Python_InitShadowInstance(args);
47616 }
47617
47618 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47619 PyObject *resultobj = 0;
47620 int arg1 = (int) 1 ;
47621 int arg2 = (int) 0 ;
47622 int arg3 = (int) 0 ;
47623 int arg4 = (int) 0 ;
47624 wxFlexGridSizer *result = 0 ;
47625 int val1 ;
47626 int ecode1 = 0 ;
47627 int val2 ;
47628 int ecode2 = 0 ;
47629 int val3 ;
47630 int ecode3 = 0 ;
47631 int val4 ;
47632 int ecode4 = 0 ;
47633 PyObject * obj0 = 0 ;
47634 PyObject * obj1 = 0 ;
47635 PyObject * obj2 = 0 ;
47636 PyObject * obj3 = 0 ;
47637 char * kwnames[] = {
47638 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47639 };
47640
47641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47642 if (obj0) {
47643 ecode1 = SWIG_AsVal_int(obj0, &val1);
47644 if (!SWIG_IsOK(ecode1)) {
47645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47646 }
47647 arg1 = static_cast< int >(val1);
47648 }
47649 if (obj1) {
47650 ecode2 = SWIG_AsVal_int(obj1, &val2);
47651 if (!SWIG_IsOK(ecode2)) {
47652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47653 }
47654 arg2 = static_cast< int >(val2);
47655 }
47656 if (obj2) {
47657 ecode3 = SWIG_AsVal_int(obj2, &val3);
47658 if (!SWIG_IsOK(ecode3)) {
47659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47660 }
47661 arg3 = static_cast< int >(val3);
47662 }
47663 if (obj3) {
47664 ecode4 = SWIG_AsVal_int(obj3, &val4);
47665 if (!SWIG_IsOK(ecode4)) {
47666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47667 }
47668 arg4 = static_cast< int >(val4);
47669 }
47670 {
47671 PyThreadState* __tstate = wxPyBeginAllowThreads();
47672 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47673 wxPyEndAllowThreads(__tstate);
47674 if (PyErr_Occurred()) SWIG_fail;
47675 }
47676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47677 return resultobj;
47678 fail:
47679 return NULL;
47680 }
47681
47682
47683 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47684 PyObject *resultobj = 0;
47685 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47686 size_t arg2 ;
47687 int arg3 = (int) 0 ;
47688 void *argp1 = 0 ;
47689 int res1 = 0 ;
47690 size_t val2 ;
47691 int ecode2 = 0 ;
47692 int val3 ;
47693 int ecode3 = 0 ;
47694 PyObject * obj0 = 0 ;
47695 PyObject * obj1 = 0 ;
47696 PyObject * obj2 = 0 ;
47697 char * kwnames[] = {
47698 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47699 };
47700
47701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47703 if (!SWIG_IsOK(res1)) {
47704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47705 }
47706 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47707 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47708 if (!SWIG_IsOK(ecode2)) {
47709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47710 }
47711 arg2 = static_cast< size_t >(val2);
47712 if (obj2) {
47713 ecode3 = SWIG_AsVal_int(obj2, &val3);
47714 if (!SWIG_IsOK(ecode3)) {
47715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47716 }
47717 arg3 = static_cast< int >(val3);
47718 }
47719 {
47720 PyThreadState* __tstate = wxPyBeginAllowThreads();
47721 (arg1)->AddGrowableRow(arg2,arg3);
47722 wxPyEndAllowThreads(__tstate);
47723 if (PyErr_Occurred()) SWIG_fail;
47724 }
47725 resultobj = SWIG_Py_Void();
47726 return resultobj;
47727 fail:
47728 return NULL;
47729 }
47730
47731
47732 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47733 PyObject *resultobj = 0;
47734 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47735 size_t arg2 ;
47736 void *argp1 = 0 ;
47737 int res1 = 0 ;
47738 size_t val2 ;
47739 int ecode2 = 0 ;
47740 PyObject * obj0 = 0 ;
47741 PyObject * obj1 = 0 ;
47742 char * kwnames[] = {
47743 (char *) "self",(char *) "idx", NULL
47744 };
47745
47746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47748 if (!SWIG_IsOK(res1)) {
47749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47750 }
47751 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47752 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47753 if (!SWIG_IsOK(ecode2)) {
47754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47755 }
47756 arg2 = static_cast< size_t >(val2);
47757 {
47758 PyThreadState* __tstate = wxPyBeginAllowThreads();
47759 (arg1)->RemoveGrowableRow(arg2);
47760 wxPyEndAllowThreads(__tstate);
47761 if (PyErr_Occurred()) SWIG_fail;
47762 }
47763 resultobj = SWIG_Py_Void();
47764 return resultobj;
47765 fail:
47766 return NULL;
47767 }
47768
47769
47770 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47771 PyObject *resultobj = 0;
47772 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47773 size_t arg2 ;
47774 int arg3 = (int) 0 ;
47775 void *argp1 = 0 ;
47776 int res1 = 0 ;
47777 size_t val2 ;
47778 int ecode2 = 0 ;
47779 int val3 ;
47780 int ecode3 = 0 ;
47781 PyObject * obj0 = 0 ;
47782 PyObject * obj1 = 0 ;
47783 PyObject * obj2 = 0 ;
47784 char * kwnames[] = {
47785 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47786 };
47787
47788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47790 if (!SWIG_IsOK(res1)) {
47791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47792 }
47793 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47794 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47795 if (!SWIG_IsOK(ecode2)) {
47796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47797 }
47798 arg2 = static_cast< size_t >(val2);
47799 if (obj2) {
47800 ecode3 = SWIG_AsVal_int(obj2, &val3);
47801 if (!SWIG_IsOK(ecode3)) {
47802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47803 }
47804 arg3 = static_cast< int >(val3);
47805 }
47806 {
47807 PyThreadState* __tstate = wxPyBeginAllowThreads();
47808 (arg1)->AddGrowableCol(arg2,arg3);
47809 wxPyEndAllowThreads(__tstate);
47810 if (PyErr_Occurred()) SWIG_fail;
47811 }
47812 resultobj = SWIG_Py_Void();
47813 return resultobj;
47814 fail:
47815 return NULL;
47816 }
47817
47818
47819 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47820 PyObject *resultobj = 0;
47821 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47822 size_t arg2 ;
47823 void *argp1 = 0 ;
47824 int res1 = 0 ;
47825 size_t val2 ;
47826 int ecode2 = 0 ;
47827 PyObject * obj0 = 0 ;
47828 PyObject * obj1 = 0 ;
47829 char * kwnames[] = {
47830 (char *) "self",(char *) "idx", NULL
47831 };
47832
47833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47835 if (!SWIG_IsOK(res1)) {
47836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47837 }
47838 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47839 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47840 if (!SWIG_IsOK(ecode2)) {
47841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47842 }
47843 arg2 = static_cast< size_t >(val2);
47844 {
47845 PyThreadState* __tstate = wxPyBeginAllowThreads();
47846 (arg1)->RemoveGrowableCol(arg2);
47847 wxPyEndAllowThreads(__tstate);
47848 if (PyErr_Occurred()) SWIG_fail;
47849 }
47850 resultobj = SWIG_Py_Void();
47851 return resultobj;
47852 fail:
47853 return NULL;
47854 }
47855
47856
47857 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47858 PyObject *resultobj = 0;
47859 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47860 int arg2 ;
47861 void *argp1 = 0 ;
47862 int res1 = 0 ;
47863 int val2 ;
47864 int ecode2 = 0 ;
47865 PyObject * obj0 = 0 ;
47866 PyObject * obj1 = 0 ;
47867 char * kwnames[] = {
47868 (char *) "self",(char *) "direction", NULL
47869 };
47870
47871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47873 if (!SWIG_IsOK(res1)) {
47874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47875 }
47876 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47877 ecode2 = SWIG_AsVal_int(obj1, &val2);
47878 if (!SWIG_IsOK(ecode2)) {
47879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47880 }
47881 arg2 = static_cast< int >(val2);
47882 {
47883 PyThreadState* __tstate = wxPyBeginAllowThreads();
47884 (arg1)->SetFlexibleDirection(arg2);
47885 wxPyEndAllowThreads(__tstate);
47886 if (PyErr_Occurred()) SWIG_fail;
47887 }
47888 resultobj = SWIG_Py_Void();
47889 return resultobj;
47890 fail:
47891 return NULL;
47892 }
47893
47894
47895 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47896 PyObject *resultobj = 0;
47897 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47898 int result;
47899 void *argp1 = 0 ;
47900 int res1 = 0 ;
47901 PyObject *swig_obj[1] ;
47902
47903 if (!args) SWIG_fail;
47904 swig_obj[0] = args;
47905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47906 if (!SWIG_IsOK(res1)) {
47907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47908 }
47909 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47910 {
47911 PyThreadState* __tstate = wxPyBeginAllowThreads();
47912 result = (int)(arg1)->GetFlexibleDirection();
47913 wxPyEndAllowThreads(__tstate);
47914 if (PyErr_Occurred()) SWIG_fail;
47915 }
47916 resultobj = SWIG_From_int(static_cast< int >(result));
47917 return resultobj;
47918 fail:
47919 return NULL;
47920 }
47921
47922
47923 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47924 PyObject *resultobj = 0;
47925 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47926 wxFlexSizerGrowMode arg2 ;
47927 void *argp1 = 0 ;
47928 int res1 = 0 ;
47929 int val2 ;
47930 int ecode2 = 0 ;
47931 PyObject * obj0 = 0 ;
47932 PyObject * obj1 = 0 ;
47933 char * kwnames[] = {
47934 (char *) "self",(char *) "mode", NULL
47935 };
47936
47937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47939 if (!SWIG_IsOK(res1)) {
47940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47941 }
47942 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47943 ecode2 = SWIG_AsVal_int(obj1, &val2);
47944 if (!SWIG_IsOK(ecode2)) {
47945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47946 }
47947 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47948 {
47949 PyThreadState* __tstate = wxPyBeginAllowThreads();
47950 (arg1)->SetNonFlexibleGrowMode(arg2);
47951 wxPyEndAllowThreads(__tstate);
47952 if (PyErr_Occurred()) SWIG_fail;
47953 }
47954 resultobj = SWIG_Py_Void();
47955 return resultobj;
47956 fail:
47957 return NULL;
47958 }
47959
47960
47961 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47962 PyObject *resultobj = 0;
47963 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47964 wxFlexSizerGrowMode result;
47965 void *argp1 = 0 ;
47966 int res1 = 0 ;
47967 PyObject *swig_obj[1] ;
47968
47969 if (!args) SWIG_fail;
47970 swig_obj[0] = args;
47971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47972 if (!SWIG_IsOK(res1)) {
47973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47974 }
47975 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_From_int(static_cast< int >(result));
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47990 PyObject *resultobj = 0;
47991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47992 wxArrayInt *result = 0 ;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 PyObject *swig_obj[1] ;
47996
47997 if (!args) SWIG_fail;
47998 swig_obj[0] = args;
47999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48002 }
48003 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48004 {
48005 PyThreadState* __tstate = wxPyBeginAllowThreads();
48006 {
48007 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48008 result = (wxArrayInt *) &_result_ref;
48009 }
48010 wxPyEndAllowThreads(__tstate);
48011 if (PyErr_Occurred()) SWIG_fail;
48012 }
48013 {
48014 resultobj = PyList_New(0);
48015 size_t idx;
48016 for (idx = 0; idx < result->GetCount(); idx += 1) {
48017 PyObject* val = PyInt_FromLong( result->Item(idx) );
48018 PyList_Append(resultobj, val);
48019 Py_DECREF(val);
48020 }
48021 }
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48029 PyObject *resultobj = 0;
48030 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48031 wxArrayInt *result = 0 ;
48032 void *argp1 = 0 ;
48033 int res1 = 0 ;
48034 PyObject *swig_obj[1] ;
48035
48036 if (!args) SWIG_fail;
48037 swig_obj[0] = args;
48038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48039 if (!SWIG_IsOK(res1)) {
48040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48041 }
48042 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48043 {
48044 PyThreadState* __tstate = wxPyBeginAllowThreads();
48045 {
48046 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48047 result = (wxArrayInt *) &_result_ref;
48048 }
48049 wxPyEndAllowThreads(__tstate);
48050 if (PyErr_Occurred()) SWIG_fail;
48051 }
48052 {
48053 resultobj = PyList_New(0);
48054 size_t idx;
48055 for (idx = 0; idx < result->GetCount(); idx += 1) {
48056 PyObject* val = PyInt_FromLong( result->Item(idx) );
48057 PyList_Append(resultobj, val);
48058 Py_DECREF(val);
48059 }
48060 }
48061 return resultobj;
48062 fail:
48063 return NULL;
48064 }
48065
48066
48067 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48068 PyObject *obj;
48069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48070 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48071 return SWIG_Py_Void();
48072 }
48073
48074 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48075 return SWIG_Python_InitShadowInstance(args);
48076 }
48077
48078 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48079 PyObject *resultobj = 0;
48080 wxStdDialogButtonSizer *result = 0 ;
48081
48082 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48083 {
48084 PyThreadState* __tstate = wxPyBeginAllowThreads();
48085 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48086 wxPyEndAllowThreads(__tstate);
48087 if (PyErr_Occurred()) SWIG_fail;
48088 }
48089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48090 return resultobj;
48091 fail:
48092 return NULL;
48093 }
48094
48095
48096 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48097 PyObject *resultobj = 0;
48098 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48099 wxButton *arg2 = (wxButton *) 0 ;
48100 void *argp1 = 0 ;
48101 int res1 = 0 ;
48102 void *argp2 = 0 ;
48103 int res2 = 0 ;
48104 PyObject * obj0 = 0 ;
48105 PyObject * obj1 = 0 ;
48106 char * kwnames[] = {
48107 (char *) "self",(char *) "button", NULL
48108 };
48109
48110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48112 if (!SWIG_IsOK(res1)) {
48113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48114 }
48115 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48117 if (!SWIG_IsOK(res2)) {
48118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48119 }
48120 arg2 = reinterpret_cast< wxButton * >(argp2);
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 (arg1)->AddButton(arg2);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_Py_Void();
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48135 PyObject *resultobj = 0;
48136 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48137 void *argp1 = 0 ;
48138 int res1 = 0 ;
48139 PyObject *swig_obj[1] ;
48140
48141 if (!args) SWIG_fail;
48142 swig_obj[0] = args;
48143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48144 if (!SWIG_IsOK(res1)) {
48145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48146 }
48147 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48148 {
48149 PyThreadState* __tstate = wxPyBeginAllowThreads();
48150 (arg1)->Realize();
48151 wxPyEndAllowThreads(__tstate);
48152 if (PyErr_Occurred()) SWIG_fail;
48153 }
48154 resultobj = SWIG_Py_Void();
48155 return resultobj;
48156 fail:
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48162 PyObject *resultobj = 0;
48163 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48164 wxButton *arg2 = (wxButton *) 0 ;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 void *argp2 = 0 ;
48168 int res2 = 0 ;
48169 PyObject * obj0 = 0 ;
48170 PyObject * obj1 = 0 ;
48171 char * kwnames[] = {
48172 (char *) "self",(char *) "button", NULL
48173 };
48174
48175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48177 if (!SWIG_IsOK(res1)) {
48178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48179 }
48180 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48182 if (!SWIG_IsOK(res2)) {
48183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48184 }
48185 arg2 = reinterpret_cast< wxButton * >(argp2);
48186 {
48187 PyThreadState* __tstate = wxPyBeginAllowThreads();
48188 (arg1)->SetAffirmativeButton(arg2);
48189 wxPyEndAllowThreads(__tstate);
48190 if (PyErr_Occurred()) SWIG_fail;
48191 }
48192 resultobj = SWIG_Py_Void();
48193 return resultobj;
48194 fail:
48195 return NULL;
48196 }
48197
48198
48199 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48200 PyObject *resultobj = 0;
48201 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48202 wxButton *arg2 = (wxButton *) 0 ;
48203 void *argp1 = 0 ;
48204 int res1 = 0 ;
48205 void *argp2 = 0 ;
48206 int res2 = 0 ;
48207 PyObject * obj0 = 0 ;
48208 PyObject * obj1 = 0 ;
48209 char * kwnames[] = {
48210 (char *) "self",(char *) "button", NULL
48211 };
48212
48213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48215 if (!SWIG_IsOK(res1)) {
48216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48217 }
48218 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48220 if (!SWIG_IsOK(res2)) {
48221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48222 }
48223 arg2 = reinterpret_cast< wxButton * >(argp2);
48224 {
48225 PyThreadState* __tstate = wxPyBeginAllowThreads();
48226 (arg1)->SetNegativeButton(arg2);
48227 wxPyEndAllowThreads(__tstate);
48228 if (PyErr_Occurred()) SWIG_fail;
48229 }
48230 resultobj = SWIG_Py_Void();
48231 return resultobj;
48232 fail:
48233 return NULL;
48234 }
48235
48236
48237 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48238 PyObject *resultobj = 0;
48239 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48240 wxButton *arg2 = (wxButton *) 0 ;
48241 void *argp1 = 0 ;
48242 int res1 = 0 ;
48243 void *argp2 = 0 ;
48244 int res2 = 0 ;
48245 PyObject * obj0 = 0 ;
48246 PyObject * obj1 = 0 ;
48247 char * kwnames[] = {
48248 (char *) "self",(char *) "button", NULL
48249 };
48250
48251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48253 if (!SWIG_IsOK(res1)) {
48254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48255 }
48256 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48258 if (!SWIG_IsOK(res2)) {
48259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48260 }
48261 arg2 = reinterpret_cast< wxButton * >(argp2);
48262 {
48263 PyThreadState* __tstate = wxPyBeginAllowThreads();
48264 (arg1)->SetCancelButton(arg2);
48265 wxPyEndAllowThreads(__tstate);
48266 if (PyErr_Occurred()) SWIG_fail;
48267 }
48268 resultobj = SWIG_Py_Void();
48269 return resultobj;
48270 fail:
48271 return NULL;
48272 }
48273
48274
48275 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48276 PyObject *resultobj = 0;
48277 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48278 wxButton *result = 0 ;
48279 void *argp1 = 0 ;
48280 int res1 = 0 ;
48281 PyObject *swig_obj[1] ;
48282
48283 if (!args) SWIG_fail;
48284 swig_obj[0] = args;
48285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48286 if (!SWIG_IsOK(res1)) {
48287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48288 }
48289 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48290 {
48291 PyThreadState* __tstate = wxPyBeginAllowThreads();
48292 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48293 wxPyEndAllowThreads(__tstate);
48294 if (PyErr_Occurred()) SWIG_fail;
48295 }
48296 {
48297 resultobj = wxPyMake_wxObject(result, (bool)0);
48298 }
48299 return resultobj;
48300 fail:
48301 return NULL;
48302 }
48303
48304
48305 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48306 PyObject *resultobj = 0;
48307 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48308 wxButton *result = 0 ;
48309 void *argp1 = 0 ;
48310 int res1 = 0 ;
48311 PyObject *swig_obj[1] ;
48312
48313 if (!args) SWIG_fail;
48314 swig_obj[0] = args;
48315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48316 if (!SWIG_IsOK(res1)) {
48317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48318 }
48319 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48320 {
48321 PyThreadState* __tstate = wxPyBeginAllowThreads();
48322 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48323 wxPyEndAllowThreads(__tstate);
48324 if (PyErr_Occurred()) SWIG_fail;
48325 }
48326 {
48327 resultobj = wxPyMake_wxObject(result, (bool)0);
48328 }
48329 return resultobj;
48330 fail:
48331 return NULL;
48332 }
48333
48334
48335 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48336 PyObject *resultobj = 0;
48337 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48338 wxButton *result = 0 ;
48339 void *argp1 = 0 ;
48340 int res1 = 0 ;
48341 PyObject *swig_obj[1] ;
48342
48343 if (!args) SWIG_fail;
48344 swig_obj[0] = args;
48345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48346 if (!SWIG_IsOK(res1)) {
48347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48348 }
48349 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48350 {
48351 PyThreadState* __tstate = wxPyBeginAllowThreads();
48352 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48353 wxPyEndAllowThreads(__tstate);
48354 if (PyErr_Occurred()) SWIG_fail;
48355 }
48356 {
48357 resultobj = wxPyMake_wxObject(result, (bool)0);
48358 }
48359 return resultobj;
48360 fail:
48361 return NULL;
48362 }
48363
48364
48365 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48366 PyObject *resultobj = 0;
48367 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48368 wxButton *result = 0 ;
48369 void *argp1 = 0 ;
48370 int res1 = 0 ;
48371 PyObject *swig_obj[1] ;
48372
48373 if (!args) SWIG_fail;
48374 swig_obj[0] = args;
48375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48376 if (!SWIG_IsOK(res1)) {
48377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48378 }
48379 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48380 {
48381 PyThreadState* __tstate = wxPyBeginAllowThreads();
48382 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48383 wxPyEndAllowThreads(__tstate);
48384 if (PyErr_Occurred()) SWIG_fail;
48385 }
48386 {
48387 resultobj = wxPyMake_wxObject(result, (bool)0);
48388 }
48389 return resultobj;
48390 fail:
48391 return NULL;
48392 }
48393
48394
48395 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48396 PyObject *resultobj = 0;
48397 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48398 wxButton *result = 0 ;
48399 void *argp1 = 0 ;
48400 int res1 = 0 ;
48401 PyObject *swig_obj[1] ;
48402
48403 if (!args) SWIG_fail;
48404 swig_obj[0] = args;
48405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48406 if (!SWIG_IsOK(res1)) {
48407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48408 }
48409 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48410 {
48411 PyThreadState* __tstate = wxPyBeginAllowThreads();
48412 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48413 wxPyEndAllowThreads(__tstate);
48414 if (PyErr_Occurred()) SWIG_fail;
48415 }
48416 {
48417 resultobj = wxPyMake_wxObject(result, (bool)0);
48418 }
48419 return resultobj;
48420 fail:
48421 return NULL;
48422 }
48423
48424
48425 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48426 PyObject *obj;
48427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48428 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48429 return SWIG_Py_Void();
48430 }
48431
48432 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48433 return SWIG_Python_InitShadowInstance(args);
48434 }
48435
48436 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48437 PyObject *resultobj = 0;
48438 int arg1 = (int) 0 ;
48439 int arg2 = (int) 0 ;
48440 wxGBPosition *result = 0 ;
48441 int val1 ;
48442 int ecode1 = 0 ;
48443 int val2 ;
48444 int ecode2 = 0 ;
48445 PyObject * obj0 = 0 ;
48446 PyObject * obj1 = 0 ;
48447 char * kwnames[] = {
48448 (char *) "row",(char *) "col", NULL
48449 };
48450
48451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48452 if (obj0) {
48453 ecode1 = SWIG_AsVal_int(obj0, &val1);
48454 if (!SWIG_IsOK(ecode1)) {
48455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48456 }
48457 arg1 = static_cast< int >(val1);
48458 }
48459 if (obj1) {
48460 ecode2 = SWIG_AsVal_int(obj1, &val2);
48461 if (!SWIG_IsOK(ecode2)) {
48462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48463 }
48464 arg2 = static_cast< int >(val2);
48465 }
48466 {
48467 PyThreadState* __tstate = wxPyBeginAllowThreads();
48468 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48469 wxPyEndAllowThreads(__tstate);
48470 if (PyErr_Occurred()) SWIG_fail;
48471 }
48472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48473 return resultobj;
48474 fail:
48475 return NULL;
48476 }
48477
48478
48479 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48480 PyObject *resultobj = 0;
48481 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48482 void *argp1 = 0 ;
48483 int res1 = 0 ;
48484 PyObject *swig_obj[1] ;
48485
48486 if (!args) SWIG_fail;
48487 swig_obj[0] = args;
48488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48489 if (!SWIG_IsOK(res1)) {
48490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48491 }
48492 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 delete arg1;
48496
48497 wxPyEndAllowThreads(__tstate);
48498 if (PyErr_Occurred()) SWIG_fail;
48499 }
48500 resultobj = SWIG_Py_Void();
48501 return resultobj;
48502 fail:
48503 return NULL;
48504 }
48505
48506
48507 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48508 PyObject *resultobj = 0;
48509 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48510 int result;
48511 void *argp1 = 0 ;
48512 int res1 = 0 ;
48513 PyObject *swig_obj[1] ;
48514
48515 if (!args) SWIG_fail;
48516 swig_obj[0] = args;
48517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48518 if (!SWIG_IsOK(res1)) {
48519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48520 }
48521 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48522 {
48523 PyThreadState* __tstate = wxPyBeginAllowThreads();
48524 result = (int)((wxGBPosition const *)arg1)->GetRow();
48525 wxPyEndAllowThreads(__tstate);
48526 if (PyErr_Occurred()) SWIG_fail;
48527 }
48528 resultobj = SWIG_From_int(static_cast< int >(result));
48529 return resultobj;
48530 fail:
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 PyObject *resultobj = 0;
48537 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48538 int result;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 PyObject *swig_obj[1] ;
48542
48543 if (!args) SWIG_fail;
48544 swig_obj[0] = args;
48545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48548 }
48549 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48550 {
48551 PyThreadState* __tstate = wxPyBeginAllowThreads();
48552 result = (int)((wxGBPosition const *)arg1)->GetCol();
48553 wxPyEndAllowThreads(__tstate);
48554 if (PyErr_Occurred()) SWIG_fail;
48555 }
48556 resultobj = SWIG_From_int(static_cast< int >(result));
48557 return resultobj;
48558 fail:
48559 return NULL;
48560 }
48561
48562
48563 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48564 PyObject *resultobj = 0;
48565 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48566 int arg2 ;
48567 void *argp1 = 0 ;
48568 int res1 = 0 ;
48569 int val2 ;
48570 int ecode2 = 0 ;
48571 PyObject * obj0 = 0 ;
48572 PyObject * obj1 = 0 ;
48573 char * kwnames[] = {
48574 (char *) "self",(char *) "row", NULL
48575 };
48576
48577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48579 if (!SWIG_IsOK(res1)) {
48580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48581 }
48582 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48583 ecode2 = SWIG_AsVal_int(obj1, &val2);
48584 if (!SWIG_IsOK(ecode2)) {
48585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48586 }
48587 arg2 = static_cast< int >(val2);
48588 {
48589 PyThreadState* __tstate = wxPyBeginAllowThreads();
48590 (arg1)->SetRow(arg2);
48591 wxPyEndAllowThreads(__tstate);
48592 if (PyErr_Occurred()) SWIG_fail;
48593 }
48594 resultobj = SWIG_Py_Void();
48595 return resultobj;
48596 fail:
48597 return NULL;
48598 }
48599
48600
48601 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48602 PyObject *resultobj = 0;
48603 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48604 int arg2 ;
48605 void *argp1 = 0 ;
48606 int res1 = 0 ;
48607 int val2 ;
48608 int ecode2 = 0 ;
48609 PyObject * obj0 = 0 ;
48610 PyObject * obj1 = 0 ;
48611 char * kwnames[] = {
48612 (char *) "self",(char *) "col", NULL
48613 };
48614
48615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48619 }
48620 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48621 ecode2 = SWIG_AsVal_int(obj1, &val2);
48622 if (!SWIG_IsOK(ecode2)) {
48623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48624 }
48625 arg2 = static_cast< int >(val2);
48626 {
48627 PyThreadState* __tstate = wxPyBeginAllowThreads();
48628 (arg1)->SetCol(arg2);
48629 wxPyEndAllowThreads(__tstate);
48630 if (PyErr_Occurred()) SWIG_fail;
48631 }
48632 resultobj = SWIG_Py_Void();
48633 return resultobj;
48634 fail:
48635 return NULL;
48636 }
48637
48638
48639 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48640 PyObject *resultobj = 0;
48641 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48642 wxGBPosition *arg2 = 0 ;
48643 bool result;
48644 void *argp1 = 0 ;
48645 int res1 = 0 ;
48646 wxGBPosition temp2 ;
48647 PyObject * obj0 = 0 ;
48648 PyObject * obj1 = 0 ;
48649 char * kwnames[] = {
48650 (char *) "self",(char *) "other", NULL
48651 };
48652
48653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48655 if (!SWIG_IsOK(res1)) {
48656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48657 }
48658 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48659 {
48660 arg2 = &temp2;
48661 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48662 }
48663 {
48664 PyThreadState* __tstate = wxPyBeginAllowThreads();
48665 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48666 wxPyEndAllowThreads(__tstate);
48667 if (PyErr_Occurred()) SWIG_fail;
48668 }
48669 {
48670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48671 }
48672 return resultobj;
48673 fail:
48674 return NULL;
48675 }
48676
48677
48678 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48679 PyObject *resultobj = 0;
48680 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48681 wxGBPosition *arg2 = 0 ;
48682 bool result;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 wxGBPosition temp2 ;
48686 PyObject * obj0 = 0 ;
48687 PyObject * obj1 = 0 ;
48688 char * kwnames[] = {
48689 (char *) "self",(char *) "other", NULL
48690 };
48691
48692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48694 if (!SWIG_IsOK(res1)) {
48695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48696 }
48697 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48698 {
48699 arg2 = &temp2;
48700 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48701 }
48702 {
48703 PyThreadState* __tstate = wxPyBeginAllowThreads();
48704 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48705 wxPyEndAllowThreads(__tstate);
48706 if (PyErr_Occurred()) SWIG_fail;
48707 }
48708 {
48709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48710 }
48711 return resultobj;
48712 fail:
48713 return NULL;
48714 }
48715
48716
48717 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48718 PyObject *resultobj = 0;
48719 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48720 int arg2 = (int) 0 ;
48721 int arg3 = (int) 0 ;
48722 void *argp1 = 0 ;
48723 int res1 = 0 ;
48724 int val2 ;
48725 int ecode2 = 0 ;
48726 int val3 ;
48727 int ecode3 = 0 ;
48728 PyObject * obj0 = 0 ;
48729 PyObject * obj1 = 0 ;
48730 PyObject * obj2 = 0 ;
48731 char * kwnames[] = {
48732 (char *) "self",(char *) "row",(char *) "col", NULL
48733 };
48734
48735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48737 if (!SWIG_IsOK(res1)) {
48738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48739 }
48740 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48741 if (obj1) {
48742 ecode2 = SWIG_AsVal_int(obj1, &val2);
48743 if (!SWIG_IsOK(ecode2)) {
48744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48745 }
48746 arg2 = static_cast< int >(val2);
48747 }
48748 if (obj2) {
48749 ecode3 = SWIG_AsVal_int(obj2, &val3);
48750 if (!SWIG_IsOK(ecode3)) {
48751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48752 }
48753 arg3 = static_cast< int >(val3);
48754 }
48755 {
48756 PyThreadState* __tstate = wxPyBeginAllowThreads();
48757 wxGBPosition_Set(arg1,arg2,arg3);
48758 wxPyEndAllowThreads(__tstate);
48759 if (PyErr_Occurred()) SWIG_fail;
48760 }
48761 resultobj = SWIG_Py_Void();
48762 return resultobj;
48763 fail:
48764 return NULL;
48765 }
48766
48767
48768 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48769 PyObject *resultobj = 0;
48770 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48771 PyObject *result = 0 ;
48772 void *argp1 = 0 ;
48773 int res1 = 0 ;
48774 PyObject *swig_obj[1] ;
48775
48776 if (!args) SWIG_fail;
48777 swig_obj[0] = args;
48778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48779 if (!SWIG_IsOK(res1)) {
48780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48781 }
48782 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48783 {
48784 PyThreadState* __tstate = wxPyBeginAllowThreads();
48785 result = (PyObject *)wxGBPosition_Get(arg1);
48786 wxPyEndAllowThreads(__tstate);
48787 if (PyErr_Occurred()) SWIG_fail;
48788 }
48789 resultobj = result;
48790 return resultobj;
48791 fail:
48792 return NULL;
48793 }
48794
48795
48796 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48797 PyObject *obj;
48798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48799 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48800 return SWIG_Py_Void();
48801 }
48802
48803 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48804 return SWIG_Python_InitShadowInstance(args);
48805 }
48806
48807 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48808 PyObject *resultobj = 0;
48809 int arg1 = (int) 1 ;
48810 int arg2 = (int) 1 ;
48811 wxGBSpan *result = 0 ;
48812 int val1 ;
48813 int ecode1 = 0 ;
48814 int val2 ;
48815 int ecode2 = 0 ;
48816 PyObject * obj0 = 0 ;
48817 PyObject * obj1 = 0 ;
48818 char * kwnames[] = {
48819 (char *) "rowspan",(char *) "colspan", NULL
48820 };
48821
48822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48823 if (obj0) {
48824 ecode1 = SWIG_AsVal_int(obj0, &val1);
48825 if (!SWIG_IsOK(ecode1)) {
48826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48827 }
48828 arg1 = static_cast< int >(val1);
48829 }
48830 if (obj1) {
48831 ecode2 = SWIG_AsVal_int(obj1, &val2);
48832 if (!SWIG_IsOK(ecode2)) {
48833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48834 }
48835 arg2 = static_cast< int >(val2);
48836 }
48837 {
48838 PyThreadState* __tstate = wxPyBeginAllowThreads();
48839 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48840 wxPyEndAllowThreads(__tstate);
48841 if (PyErr_Occurred()) SWIG_fail;
48842 }
48843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 PyObject *resultobj = 0;
48852 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48853 void *argp1 = 0 ;
48854 int res1 = 0 ;
48855 PyObject *swig_obj[1] ;
48856
48857 if (!args) SWIG_fail;
48858 swig_obj[0] = args;
48859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48860 if (!SWIG_IsOK(res1)) {
48861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48862 }
48863 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48864 {
48865 PyThreadState* __tstate = wxPyBeginAllowThreads();
48866 delete arg1;
48867
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 resultobj = SWIG_Py_Void();
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48879 PyObject *resultobj = 0;
48880 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48881 int result;
48882 void *argp1 = 0 ;
48883 int res1 = 0 ;
48884 PyObject *swig_obj[1] ;
48885
48886 if (!args) SWIG_fail;
48887 swig_obj[0] = args;
48888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48889 if (!SWIG_IsOK(res1)) {
48890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48891 }
48892 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48893 {
48894 PyThreadState* __tstate = wxPyBeginAllowThreads();
48895 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48896 wxPyEndAllowThreads(__tstate);
48897 if (PyErr_Occurred()) SWIG_fail;
48898 }
48899 resultobj = SWIG_From_int(static_cast< int >(result));
48900 return resultobj;
48901 fail:
48902 return NULL;
48903 }
48904
48905
48906 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48907 PyObject *resultobj = 0;
48908 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48909 int result;
48910 void *argp1 = 0 ;
48911 int res1 = 0 ;
48912 PyObject *swig_obj[1] ;
48913
48914 if (!args) SWIG_fail;
48915 swig_obj[0] = args;
48916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48917 if (!SWIG_IsOK(res1)) {
48918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48919 }
48920 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48921 {
48922 PyThreadState* __tstate = wxPyBeginAllowThreads();
48923 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48924 wxPyEndAllowThreads(__tstate);
48925 if (PyErr_Occurred()) SWIG_fail;
48926 }
48927 resultobj = SWIG_From_int(static_cast< int >(result));
48928 return resultobj;
48929 fail:
48930 return NULL;
48931 }
48932
48933
48934 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48935 PyObject *resultobj = 0;
48936 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48937 int arg2 ;
48938 void *argp1 = 0 ;
48939 int res1 = 0 ;
48940 int val2 ;
48941 int ecode2 = 0 ;
48942 PyObject * obj0 = 0 ;
48943 PyObject * obj1 = 0 ;
48944 char * kwnames[] = {
48945 (char *) "self",(char *) "rowspan", NULL
48946 };
48947
48948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48950 if (!SWIG_IsOK(res1)) {
48951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48952 }
48953 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48954 ecode2 = SWIG_AsVal_int(obj1, &val2);
48955 if (!SWIG_IsOK(ecode2)) {
48956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48957 }
48958 arg2 = static_cast< int >(val2);
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 (arg1)->SetRowspan(arg2);
48962 wxPyEndAllowThreads(__tstate);
48963 if (PyErr_Occurred()) SWIG_fail;
48964 }
48965 resultobj = SWIG_Py_Void();
48966 return resultobj;
48967 fail:
48968 return NULL;
48969 }
48970
48971
48972 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48973 PyObject *resultobj = 0;
48974 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48975 int arg2 ;
48976 void *argp1 = 0 ;
48977 int res1 = 0 ;
48978 int val2 ;
48979 int ecode2 = 0 ;
48980 PyObject * obj0 = 0 ;
48981 PyObject * obj1 = 0 ;
48982 char * kwnames[] = {
48983 (char *) "self",(char *) "colspan", NULL
48984 };
48985
48986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
48987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48988 if (!SWIG_IsOK(res1)) {
48989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48990 }
48991 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48992 ecode2 = SWIG_AsVal_int(obj1, &val2);
48993 if (!SWIG_IsOK(ecode2)) {
48994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
48995 }
48996 arg2 = static_cast< int >(val2);
48997 {
48998 PyThreadState* __tstate = wxPyBeginAllowThreads();
48999 (arg1)->SetColspan(arg2);
49000 wxPyEndAllowThreads(__tstate);
49001 if (PyErr_Occurred()) SWIG_fail;
49002 }
49003 resultobj = SWIG_Py_Void();
49004 return resultobj;
49005 fail:
49006 return NULL;
49007 }
49008
49009
49010 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49011 PyObject *resultobj = 0;
49012 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49013 wxGBSpan *arg2 = 0 ;
49014 bool result;
49015 void *argp1 = 0 ;
49016 int res1 = 0 ;
49017 wxGBSpan temp2 ;
49018 PyObject * obj0 = 0 ;
49019 PyObject * obj1 = 0 ;
49020 char * kwnames[] = {
49021 (char *) "self",(char *) "other", NULL
49022 };
49023
49024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49026 if (!SWIG_IsOK(res1)) {
49027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49028 }
49029 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49030 {
49031 arg2 = &temp2;
49032 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49033 }
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49037 wxPyEndAllowThreads(__tstate);
49038 if (PyErr_Occurred()) SWIG_fail;
49039 }
49040 {
49041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49042 }
49043 return resultobj;
49044 fail:
49045 return NULL;
49046 }
49047
49048
49049 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49050 PyObject *resultobj = 0;
49051 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49052 wxGBSpan *arg2 = 0 ;
49053 bool result;
49054 void *argp1 = 0 ;
49055 int res1 = 0 ;
49056 wxGBSpan temp2 ;
49057 PyObject * obj0 = 0 ;
49058 PyObject * obj1 = 0 ;
49059 char * kwnames[] = {
49060 (char *) "self",(char *) "other", NULL
49061 };
49062
49063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49065 if (!SWIG_IsOK(res1)) {
49066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49067 }
49068 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49069 {
49070 arg2 = &temp2;
49071 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49072 }
49073 {
49074 PyThreadState* __tstate = wxPyBeginAllowThreads();
49075 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49076 wxPyEndAllowThreads(__tstate);
49077 if (PyErr_Occurred()) SWIG_fail;
49078 }
49079 {
49080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49081 }
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49089 PyObject *resultobj = 0;
49090 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49091 int arg2 = (int) 1 ;
49092 int arg3 = (int) 1 ;
49093 void *argp1 = 0 ;
49094 int res1 = 0 ;
49095 int val2 ;
49096 int ecode2 = 0 ;
49097 int val3 ;
49098 int ecode3 = 0 ;
49099 PyObject * obj0 = 0 ;
49100 PyObject * obj1 = 0 ;
49101 PyObject * obj2 = 0 ;
49102 char * kwnames[] = {
49103 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49104 };
49105
49106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49108 if (!SWIG_IsOK(res1)) {
49109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49110 }
49111 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49112 if (obj1) {
49113 ecode2 = SWIG_AsVal_int(obj1, &val2);
49114 if (!SWIG_IsOK(ecode2)) {
49115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49116 }
49117 arg2 = static_cast< int >(val2);
49118 }
49119 if (obj2) {
49120 ecode3 = SWIG_AsVal_int(obj2, &val3);
49121 if (!SWIG_IsOK(ecode3)) {
49122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49123 }
49124 arg3 = static_cast< int >(val3);
49125 }
49126 {
49127 PyThreadState* __tstate = wxPyBeginAllowThreads();
49128 wxGBSpan_Set(arg1,arg2,arg3);
49129 wxPyEndAllowThreads(__tstate);
49130 if (PyErr_Occurred()) SWIG_fail;
49131 }
49132 resultobj = SWIG_Py_Void();
49133 return resultobj;
49134 fail:
49135 return NULL;
49136 }
49137
49138
49139 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49140 PyObject *resultobj = 0;
49141 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49142 PyObject *result = 0 ;
49143 void *argp1 = 0 ;
49144 int res1 = 0 ;
49145 PyObject *swig_obj[1] ;
49146
49147 if (!args) SWIG_fail;
49148 swig_obj[0] = args;
49149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49150 if (!SWIG_IsOK(res1)) {
49151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49152 }
49153 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49154 {
49155 PyThreadState* __tstate = wxPyBeginAllowThreads();
49156 result = (PyObject *)wxGBSpan_Get(arg1);
49157 wxPyEndAllowThreads(__tstate);
49158 if (PyErr_Occurred()) SWIG_fail;
49159 }
49160 resultobj = result;
49161 return resultobj;
49162 fail:
49163 return NULL;
49164 }
49165
49166
49167 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49168 PyObject *obj;
49169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49170 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49171 return SWIG_Py_Void();
49172 }
49173
49174 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49175 return SWIG_Python_InitShadowInstance(args);
49176 }
49177
49178 SWIGINTERN int DefaultSpan_set(PyObject *) {
49179 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49180 return 1;
49181 }
49182
49183
49184 SWIGINTERN PyObject *DefaultSpan_get(void) {
49185 PyObject *pyobj = 0;
49186
49187 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49188 return pyobj;
49189 }
49190
49191
49192 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49193 PyObject *resultobj = 0;
49194 wxGBSizerItem *result = 0 ;
49195
49196 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49197 {
49198 PyThreadState* __tstate = wxPyBeginAllowThreads();
49199 result = (wxGBSizerItem *)new wxGBSizerItem();
49200 wxPyEndAllowThreads(__tstate);
49201 if (PyErr_Occurred()) SWIG_fail;
49202 }
49203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49211 PyObject *resultobj = 0;
49212 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49213 void *argp1 = 0 ;
49214 int res1 = 0 ;
49215 PyObject *swig_obj[1] ;
49216
49217 if (!args) SWIG_fail;
49218 swig_obj[0] = args;
49219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49220 if (!SWIG_IsOK(res1)) {
49221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49222 }
49223 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49224 {
49225 PyThreadState* __tstate = wxPyBeginAllowThreads();
49226 delete arg1;
49227
49228 wxPyEndAllowThreads(__tstate);
49229 if (PyErr_Occurred()) SWIG_fail;
49230 }
49231 resultobj = SWIG_Py_Void();
49232 return resultobj;
49233 fail:
49234 return NULL;
49235 }
49236
49237
49238 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49239 PyObject *resultobj = 0;
49240 wxWindow *arg1 = (wxWindow *) 0 ;
49241 wxGBPosition *arg2 = 0 ;
49242 wxGBSpan *arg3 = 0 ;
49243 int arg4 ;
49244 int arg5 ;
49245 PyObject *arg6 = (PyObject *) NULL ;
49246 wxGBSizerItem *result = 0 ;
49247 void *argp1 = 0 ;
49248 int res1 = 0 ;
49249 wxGBPosition temp2 ;
49250 wxGBSpan temp3 ;
49251 int val4 ;
49252 int ecode4 = 0 ;
49253 int val5 ;
49254 int ecode5 = 0 ;
49255 PyObject * obj0 = 0 ;
49256 PyObject * obj1 = 0 ;
49257 PyObject * obj2 = 0 ;
49258 PyObject * obj3 = 0 ;
49259 PyObject * obj4 = 0 ;
49260 PyObject * obj5 = 0 ;
49261 char * kwnames[] = {
49262 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49263 };
49264
49265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49267 if (!SWIG_IsOK(res1)) {
49268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49269 }
49270 arg1 = reinterpret_cast< wxWindow * >(argp1);
49271 {
49272 arg2 = &temp2;
49273 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49274 }
49275 {
49276 arg3 = &temp3;
49277 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49278 }
49279 ecode4 = SWIG_AsVal_int(obj3, &val4);
49280 if (!SWIG_IsOK(ecode4)) {
49281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49282 }
49283 arg4 = static_cast< int >(val4);
49284 ecode5 = SWIG_AsVal_int(obj4, &val5);
49285 if (!SWIG_IsOK(ecode5)) {
49286 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49287 }
49288 arg5 = static_cast< int >(val5);
49289 if (obj5) {
49290 arg6 = obj5;
49291 }
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49295 wxPyEndAllowThreads(__tstate);
49296 if (PyErr_Occurred()) SWIG_fail;
49297 }
49298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49299 return resultobj;
49300 fail:
49301 return NULL;
49302 }
49303
49304
49305 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49306 PyObject *resultobj = 0;
49307 wxSizer *arg1 = (wxSizer *) 0 ;
49308 wxGBPosition *arg2 = 0 ;
49309 wxGBSpan *arg3 = 0 ;
49310 int arg4 ;
49311 int arg5 ;
49312 PyObject *arg6 = (PyObject *) NULL ;
49313 wxGBSizerItem *result = 0 ;
49314 int res1 = 0 ;
49315 wxGBPosition temp2 ;
49316 wxGBSpan temp3 ;
49317 int val4 ;
49318 int ecode4 = 0 ;
49319 int val5 ;
49320 int ecode5 = 0 ;
49321 PyObject * obj0 = 0 ;
49322 PyObject * obj1 = 0 ;
49323 PyObject * obj2 = 0 ;
49324 PyObject * obj3 = 0 ;
49325 PyObject * obj4 = 0 ;
49326 PyObject * obj5 = 0 ;
49327 char * kwnames[] = {
49328 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49329 };
49330
49331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49332 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49333 if (!SWIG_IsOK(res1)) {
49334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49335 }
49336 {
49337 arg2 = &temp2;
49338 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49339 }
49340 {
49341 arg3 = &temp3;
49342 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49343 }
49344 ecode4 = SWIG_AsVal_int(obj3, &val4);
49345 if (!SWIG_IsOK(ecode4)) {
49346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49347 }
49348 arg4 = static_cast< int >(val4);
49349 ecode5 = SWIG_AsVal_int(obj4, &val5);
49350 if (!SWIG_IsOK(ecode5)) {
49351 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49352 }
49353 arg5 = static_cast< int >(val5);
49354 if (obj5) {
49355 arg6 = obj5;
49356 }
49357 {
49358 PyThreadState* __tstate = wxPyBeginAllowThreads();
49359 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49360 wxPyEndAllowThreads(__tstate);
49361 if (PyErr_Occurred()) SWIG_fail;
49362 }
49363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49364 return resultobj;
49365 fail:
49366 return NULL;
49367 }
49368
49369
49370 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49371 PyObject *resultobj = 0;
49372 int arg1 ;
49373 int arg2 ;
49374 wxGBPosition *arg3 = 0 ;
49375 wxGBSpan *arg4 = 0 ;
49376 int arg5 ;
49377 int arg6 ;
49378 PyObject *arg7 = (PyObject *) NULL ;
49379 wxGBSizerItem *result = 0 ;
49380 int val1 ;
49381 int ecode1 = 0 ;
49382 int val2 ;
49383 int ecode2 = 0 ;
49384 wxGBPosition temp3 ;
49385 wxGBSpan temp4 ;
49386 int val5 ;
49387 int ecode5 = 0 ;
49388 int val6 ;
49389 int ecode6 = 0 ;
49390 PyObject * obj0 = 0 ;
49391 PyObject * obj1 = 0 ;
49392 PyObject * obj2 = 0 ;
49393 PyObject * obj3 = 0 ;
49394 PyObject * obj4 = 0 ;
49395 PyObject * obj5 = 0 ;
49396 PyObject * obj6 = 0 ;
49397 char * kwnames[] = {
49398 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49399 };
49400
49401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49402 ecode1 = SWIG_AsVal_int(obj0, &val1);
49403 if (!SWIG_IsOK(ecode1)) {
49404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49405 }
49406 arg1 = static_cast< int >(val1);
49407 ecode2 = SWIG_AsVal_int(obj1, &val2);
49408 if (!SWIG_IsOK(ecode2)) {
49409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49410 }
49411 arg2 = static_cast< int >(val2);
49412 {
49413 arg3 = &temp3;
49414 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49415 }
49416 {
49417 arg4 = &temp4;
49418 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49419 }
49420 ecode5 = SWIG_AsVal_int(obj4, &val5);
49421 if (!SWIG_IsOK(ecode5)) {
49422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49423 }
49424 arg5 = static_cast< int >(val5);
49425 ecode6 = SWIG_AsVal_int(obj5, &val6);
49426 if (!SWIG_IsOK(ecode6)) {
49427 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49428 }
49429 arg6 = static_cast< int >(val6);
49430 if (obj6) {
49431 arg7 = obj6;
49432 }
49433 {
49434 PyThreadState* __tstate = wxPyBeginAllowThreads();
49435 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49436 wxPyEndAllowThreads(__tstate);
49437 if (PyErr_Occurred()) SWIG_fail;
49438 }
49439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49440 return resultobj;
49441 fail:
49442 return NULL;
49443 }
49444
49445
49446 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49447 PyObject *resultobj = 0;
49448 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49449 wxGBPosition result;
49450 void *argp1 = 0 ;
49451 int res1 = 0 ;
49452 PyObject *swig_obj[1] ;
49453
49454 if (!args) SWIG_fail;
49455 swig_obj[0] = args;
49456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49459 }
49460 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 result = ((wxGBSizerItem const *)arg1)->GetPos();
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49475 PyObject *resultobj = 0;
49476 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49477 wxGBSpan result;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 PyObject *swig_obj[1] ;
49481
49482 if (!args) SWIG_fail;
49483 swig_obj[0] = args;
49484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49485 if (!SWIG_IsOK(res1)) {
49486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49487 }
49488 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49489 {
49490 PyThreadState* __tstate = wxPyBeginAllowThreads();
49491 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49492 wxPyEndAllowThreads(__tstate);
49493 if (PyErr_Occurred()) SWIG_fail;
49494 }
49495 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49496 return resultobj;
49497 fail:
49498 return NULL;
49499 }
49500
49501
49502 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49503 PyObject *resultobj = 0;
49504 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49505 wxGBPosition *arg2 = 0 ;
49506 bool result;
49507 void *argp1 = 0 ;
49508 int res1 = 0 ;
49509 wxGBPosition temp2 ;
49510 PyObject * obj0 = 0 ;
49511 PyObject * obj1 = 0 ;
49512 char * kwnames[] = {
49513 (char *) "self",(char *) "pos", NULL
49514 };
49515
49516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49518 if (!SWIG_IsOK(res1)) {
49519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49520 }
49521 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49522 {
49523 arg2 = &temp2;
49524 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49525 }
49526 {
49527 PyThreadState* __tstate = wxPyBeginAllowThreads();
49528 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49529 wxPyEndAllowThreads(__tstate);
49530 if (PyErr_Occurred()) SWIG_fail;
49531 }
49532 {
49533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49534 }
49535 return resultobj;
49536 fail:
49537 return NULL;
49538 }
49539
49540
49541 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49542 PyObject *resultobj = 0;
49543 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49544 wxGBSpan *arg2 = 0 ;
49545 bool result;
49546 void *argp1 = 0 ;
49547 int res1 = 0 ;
49548 wxGBSpan temp2 ;
49549 PyObject * obj0 = 0 ;
49550 PyObject * obj1 = 0 ;
49551 char * kwnames[] = {
49552 (char *) "self",(char *) "span", NULL
49553 };
49554
49555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49557 if (!SWIG_IsOK(res1)) {
49558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49559 }
49560 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49561 {
49562 arg2 = &temp2;
49563 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49564 }
49565 {
49566 PyThreadState* __tstate = wxPyBeginAllowThreads();
49567 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49568 wxPyEndAllowThreads(__tstate);
49569 if (PyErr_Occurred()) SWIG_fail;
49570 }
49571 {
49572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49573 }
49574 return resultobj;
49575 fail:
49576 return NULL;
49577 }
49578
49579
49580 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49581 PyObject *resultobj = 0;
49582 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49583 wxGBSizerItem *arg2 = 0 ;
49584 bool result;
49585 void *argp1 = 0 ;
49586 int res1 = 0 ;
49587 void *argp2 = 0 ;
49588 int res2 = 0 ;
49589 PyObject * obj0 = 0 ;
49590 PyObject * obj1 = 0 ;
49591 char * kwnames[] = {
49592 (char *) "self",(char *) "other", NULL
49593 };
49594
49595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49597 if (!SWIG_IsOK(res1)) {
49598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49599 }
49600 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49601 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49602 if (!SWIG_IsOK(res2)) {
49603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49604 }
49605 if (!argp2) {
49606 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49607 }
49608 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49609 {
49610 PyThreadState* __tstate = wxPyBeginAllowThreads();
49611 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49612 wxPyEndAllowThreads(__tstate);
49613 if (PyErr_Occurred()) SWIG_fail;
49614 }
49615 {
49616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49617 }
49618 return resultobj;
49619 fail:
49620 return NULL;
49621 }
49622
49623
49624 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49625 PyObject *resultobj = 0;
49626 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49627 wxGBPosition *arg2 = 0 ;
49628 wxGBSpan *arg3 = 0 ;
49629 bool result;
49630 void *argp1 = 0 ;
49631 int res1 = 0 ;
49632 wxGBPosition temp2 ;
49633 wxGBSpan temp3 ;
49634 PyObject * obj0 = 0 ;
49635 PyObject * obj1 = 0 ;
49636 PyObject * obj2 = 0 ;
49637 char * kwnames[] = {
49638 (char *) "self",(char *) "pos",(char *) "span", NULL
49639 };
49640
49641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49643 if (!SWIG_IsOK(res1)) {
49644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49645 }
49646 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49647 {
49648 arg2 = &temp2;
49649 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49650 }
49651 {
49652 arg3 = &temp3;
49653 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49654 }
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 {
49662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49663 }
49664 return resultobj;
49665 fail:
49666 return NULL;
49667 }
49668
49669
49670 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49671 PyObject *resultobj = 0;
49672 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49673 wxGBPosition result;
49674 void *argp1 = 0 ;
49675 int res1 = 0 ;
49676 PyObject *swig_obj[1] ;
49677
49678 if (!args) SWIG_fail;
49679 swig_obj[0] = args;
49680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49681 if (!SWIG_IsOK(res1)) {
49682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49683 }
49684 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 result = wxGBSizerItem_GetEndPos(arg1);
49688 wxPyEndAllowThreads(__tstate);
49689 if (PyErr_Occurred()) SWIG_fail;
49690 }
49691 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49699 PyObject *resultobj = 0;
49700 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49701 wxGridBagSizer *result = 0 ;
49702 void *argp1 = 0 ;
49703 int res1 = 0 ;
49704 PyObject *swig_obj[1] ;
49705
49706 if (!args) SWIG_fail;
49707 swig_obj[0] = args;
49708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49709 if (!SWIG_IsOK(res1)) {
49710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49711 }
49712 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49713 {
49714 PyThreadState* __tstate = wxPyBeginAllowThreads();
49715 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49720 return resultobj;
49721 fail:
49722 return NULL;
49723 }
49724
49725
49726 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49727 PyObject *resultobj = 0;
49728 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49729 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49730 void *argp1 = 0 ;
49731 int res1 = 0 ;
49732 void *argp2 = 0 ;
49733 int res2 = 0 ;
49734 PyObject * obj0 = 0 ;
49735 PyObject * obj1 = 0 ;
49736 char * kwnames[] = {
49737 (char *) "self",(char *) "sizer", NULL
49738 };
49739
49740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49742 if (!SWIG_IsOK(res1)) {
49743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49744 }
49745 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49747 if (!SWIG_IsOK(res2)) {
49748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49749 }
49750 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49751 {
49752 PyThreadState* __tstate = wxPyBeginAllowThreads();
49753 (arg1)->SetGBSizer(arg2);
49754 wxPyEndAllowThreads(__tstate);
49755 if (PyErr_Occurred()) SWIG_fail;
49756 }
49757 resultobj = SWIG_Py_Void();
49758 return resultobj;
49759 fail:
49760 return NULL;
49761 }
49762
49763
49764 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49765 PyObject *obj;
49766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49767 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49768 return SWIG_Py_Void();
49769 }
49770
49771 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49772 return SWIG_Python_InitShadowInstance(args);
49773 }
49774
49775 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49776 PyObject *resultobj = 0;
49777 int arg1 = (int) 0 ;
49778 int arg2 = (int) 0 ;
49779 wxGridBagSizer *result = 0 ;
49780 int val1 ;
49781 int ecode1 = 0 ;
49782 int val2 ;
49783 int ecode2 = 0 ;
49784 PyObject * obj0 = 0 ;
49785 PyObject * obj1 = 0 ;
49786 char * kwnames[] = {
49787 (char *) "vgap",(char *) "hgap", NULL
49788 };
49789
49790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49791 if (obj0) {
49792 ecode1 = SWIG_AsVal_int(obj0, &val1);
49793 if (!SWIG_IsOK(ecode1)) {
49794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49795 }
49796 arg1 = static_cast< int >(val1);
49797 }
49798 if (obj1) {
49799 ecode2 = SWIG_AsVal_int(obj1, &val2);
49800 if (!SWIG_IsOK(ecode2)) {
49801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49802 }
49803 arg2 = static_cast< int >(val2);
49804 }
49805 {
49806 PyThreadState* __tstate = wxPyBeginAllowThreads();
49807 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49808 wxPyEndAllowThreads(__tstate);
49809 if (PyErr_Occurred()) SWIG_fail;
49810 }
49811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49812 return resultobj;
49813 fail:
49814 return NULL;
49815 }
49816
49817
49818 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49819 PyObject *resultobj = 0;
49820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49821 PyObject *arg2 = (PyObject *) 0 ;
49822 wxGBPosition *arg3 = 0 ;
49823 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49824 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49825 int arg5 = (int) 0 ;
49826 int arg6 = (int) 0 ;
49827 PyObject *arg7 = (PyObject *) NULL ;
49828 wxGBSizerItem *result = 0 ;
49829 void *argp1 = 0 ;
49830 int res1 = 0 ;
49831 wxGBPosition temp3 ;
49832 wxGBSpan temp4 ;
49833 int val5 ;
49834 int ecode5 = 0 ;
49835 int val6 ;
49836 int ecode6 = 0 ;
49837 PyObject * obj0 = 0 ;
49838 PyObject * obj1 = 0 ;
49839 PyObject * obj2 = 0 ;
49840 PyObject * obj3 = 0 ;
49841 PyObject * obj4 = 0 ;
49842 PyObject * obj5 = 0 ;
49843 PyObject * obj6 = 0 ;
49844 char * kwnames[] = {
49845 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49846 };
49847
49848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49850 if (!SWIG_IsOK(res1)) {
49851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49852 }
49853 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49854 arg2 = obj1;
49855 {
49856 arg3 = &temp3;
49857 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49858 }
49859 if (obj3) {
49860 {
49861 arg4 = &temp4;
49862 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49863 }
49864 }
49865 if (obj4) {
49866 ecode5 = SWIG_AsVal_int(obj4, &val5);
49867 if (!SWIG_IsOK(ecode5)) {
49868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49869 }
49870 arg5 = static_cast< int >(val5);
49871 }
49872 if (obj5) {
49873 ecode6 = SWIG_AsVal_int(obj5, &val6);
49874 if (!SWIG_IsOK(ecode6)) {
49875 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49876 }
49877 arg6 = static_cast< int >(val6);
49878 }
49879 if (obj6) {
49880 arg7 = obj6;
49881 }
49882 {
49883 PyThreadState* __tstate = wxPyBeginAllowThreads();
49884 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49885 wxPyEndAllowThreads(__tstate);
49886 if (PyErr_Occurred()) SWIG_fail;
49887 }
49888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49889 return resultobj;
49890 fail:
49891 return NULL;
49892 }
49893
49894
49895 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49896 PyObject *resultobj = 0;
49897 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49898 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49899 wxGBSizerItem *result = 0 ;
49900 void *argp1 = 0 ;
49901 int res1 = 0 ;
49902 int res2 = 0 ;
49903 PyObject * obj0 = 0 ;
49904 PyObject * obj1 = 0 ;
49905 char * kwnames[] = {
49906 (char *) "self",(char *) "item", NULL
49907 };
49908
49909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49911 if (!SWIG_IsOK(res1)) {
49912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49913 }
49914 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49915 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49916 if (!SWIG_IsOK(res2)) {
49917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49918 }
49919 {
49920 PyThreadState* __tstate = wxPyBeginAllowThreads();
49921 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49922 wxPyEndAllowThreads(__tstate);
49923 if (PyErr_Occurred()) SWIG_fail;
49924 }
49925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49926 return resultobj;
49927 fail:
49928 return NULL;
49929 }
49930
49931
49932 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49933 PyObject *resultobj = 0;
49934 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49935 int arg2 ;
49936 int arg3 ;
49937 wxSize result;
49938 void *argp1 = 0 ;
49939 int res1 = 0 ;
49940 int val2 ;
49941 int ecode2 = 0 ;
49942 int val3 ;
49943 int ecode3 = 0 ;
49944 PyObject * obj0 = 0 ;
49945 PyObject * obj1 = 0 ;
49946 PyObject * obj2 = 0 ;
49947 char * kwnames[] = {
49948 (char *) "self",(char *) "row",(char *) "col", NULL
49949 };
49950
49951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49953 if (!SWIG_IsOK(res1)) {
49954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49955 }
49956 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49957 ecode2 = SWIG_AsVal_int(obj1, &val2);
49958 if (!SWIG_IsOK(ecode2)) {
49959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49960 }
49961 arg2 = static_cast< int >(val2);
49962 ecode3 = SWIG_AsVal_int(obj2, &val3);
49963 if (!SWIG_IsOK(ecode3)) {
49964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49965 }
49966 arg3 = static_cast< int >(val3);
49967 {
49968 PyThreadState* __tstate = wxPyBeginAllowThreads();
49969 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49970 wxPyEndAllowThreads(__tstate);
49971 if (PyErr_Occurred()) SWIG_fail;
49972 }
49973 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49974 return resultobj;
49975 fail:
49976 return NULL;
49977 }
49978
49979
49980 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49981 PyObject *resultobj = 0;
49982 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49983 wxSize result;
49984 void *argp1 = 0 ;
49985 int res1 = 0 ;
49986 PyObject *swig_obj[1] ;
49987
49988 if (!args) SWIG_fail;
49989 swig_obj[0] = args;
49990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49991 if (!SWIG_IsOK(res1)) {
49992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49993 }
49994 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49995 {
49996 PyThreadState* __tstate = wxPyBeginAllowThreads();
49997 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
49998 wxPyEndAllowThreads(__tstate);
49999 if (PyErr_Occurred()) SWIG_fail;
50000 }
50001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50002 return resultobj;
50003 fail:
50004 return NULL;
50005 }
50006
50007
50008 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50009 PyObject *resultobj = 0;
50010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50011 wxSize *arg2 = 0 ;
50012 void *argp1 = 0 ;
50013 int res1 = 0 ;
50014 wxSize temp2 ;
50015 PyObject * obj0 = 0 ;
50016 PyObject * obj1 = 0 ;
50017 char * kwnames[] = {
50018 (char *) "self",(char *) "sz", NULL
50019 };
50020
50021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50025 }
50026 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50027 {
50028 arg2 = &temp2;
50029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50030 }
50031 {
50032 PyThreadState* __tstate = wxPyBeginAllowThreads();
50033 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50034 wxPyEndAllowThreads(__tstate);
50035 if (PyErr_Occurred()) SWIG_fail;
50036 }
50037 resultobj = SWIG_Py_Void();
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50045 PyObject *resultobj = 0;
50046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50047 wxWindow *arg2 = (wxWindow *) 0 ;
50048 wxGBPosition result;
50049 void *argp1 = 0 ;
50050 int res1 = 0 ;
50051 void *argp2 = 0 ;
50052 int res2 = 0 ;
50053
50054 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50056 if (!SWIG_IsOK(res1)) {
50057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50058 }
50059 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50060 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50061 if (!SWIG_IsOK(res2)) {
50062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50063 }
50064 arg2 = reinterpret_cast< wxWindow * >(argp2);
50065 {
50066 PyThreadState* __tstate = wxPyBeginAllowThreads();
50067 result = (arg1)->GetItemPosition(arg2);
50068 wxPyEndAllowThreads(__tstate);
50069 if (PyErr_Occurred()) SWIG_fail;
50070 }
50071 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50072 return resultobj;
50073 fail:
50074 return NULL;
50075 }
50076
50077
50078 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50079 PyObject *resultobj = 0;
50080 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50081 wxSizer *arg2 = (wxSizer *) 0 ;
50082 wxGBPosition result;
50083 void *argp1 = 0 ;
50084 int res1 = 0 ;
50085 void *argp2 = 0 ;
50086 int res2 = 0 ;
50087
50088 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50090 if (!SWIG_IsOK(res1)) {
50091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50092 }
50093 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50094 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50095 if (!SWIG_IsOK(res2)) {
50096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50097 }
50098 arg2 = reinterpret_cast< wxSizer * >(argp2);
50099 {
50100 PyThreadState* __tstate = wxPyBeginAllowThreads();
50101 result = (arg1)->GetItemPosition(arg2);
50102 wxPyEndAllowThreads(__tstate);
50103 if (PyErr_Occurred()) SWIG_fail;
50104 }
50105 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50106 return resultobj;
50107 fail:
50108 return NULL;
50109 }
50110
50111
50112 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50113 PyObject *resultobj = 0;
50114 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50115 size_t arg2 ;
50116 wxGBPosition result;
50117 void *argp1 = 0 ;
50118 int res1 = 0 ;
50119 size_t val2 ;
50120 int ecode2 = 0 ;
50121
50122 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50124 if (!SWIG_IsOK(res1)) {
50125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50126 }
50127 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50128 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50129 if (!SWIG_IsOK(ecode2)) {
50130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50131 }
50132 arg2 = static_cast< size_t >(val2);
50133 {
50134 PyThreadState* __tstate = wxPyBeginAllowThreads();
50135 result = (arg1)->GetItemPosition(arg2);
50136 wxPyEndAllowThreads(__tstate);
50137 if (PyErr_Occurred()) SWIG_fail;
50138 }
50139 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50147 int argc;
50148 PyObject *argv[3];
50149
50150 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50151 --argc;
50152 if (argc == 2) {
50153 int _v = 0;
50154 {
50155 void *vptr = 0;
50156 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50157 _v = SWIG_CheckState(res);
50158 }
50159 if (!_v) goto check_1;
50160 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50161 }
50162 check_1:
50163
50164 if (argc == 2) {
50165 int _v = 0;
50166 {
50167 void *vptr = 0;
50168 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50169 _v = SWIG_CheckState(res);
50170 }
50171 if (!_v) goto check_2;
50172 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50173 }
50174 check_2:
50175
50176 if (argc == 2) {
50177 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50178 }
50179
50180 fail:
50181 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50182 return NULL;
50183 }
50184
50185
50186 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50187 PyObject *resultobj = 0;
50188 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50189 wxWindow *arg2 = (wxWindow *) 0 ;
50190 wxGBPosition *arg3 = 0 ;
50191 bool result;
50192 void *argp1 = 0 ;
50193 int res1 = 0 ;
50194 void *argp2 = 0 ;
50195 int res2 = 0 ;
50196 wxGBPosition temp3 ;
50197
50198 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50200 if (!SWIG_IsOK(res1)) {
50201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50202 }
50203 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50204 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50205 if (!SWIG_IsOK(res2)) {
50206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50207 }
50208 arg2 = reinterpret_cast< wxWindow * >(argp2);
50209 {
50210 arg3 = &temp3;
50211 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50212 }
50213 {
50214 PyThreadState* __tstate = wxPyBeginAllowThreads();
50215 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50216 wxPyEndAllowThreads(__tstate);
50217 if (PyErr_Occurred()) SWIG_fail;
50218 }
50219 {
50220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50221 }
50222 return resultobj;
50223 fail:
50224 return NULL;
50225 }
50226
50227
50228 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50229 PyObject *resultobj = 0;
50230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50231 wxSizer *arg2 = (wxSizer *) 0 ;
50232 wxGBPosition *arg3 = 0 ;
50233 bool result;
50234 void *argp1 = 0 ;
50235 int res1 = 0 ;
50236 void *argp2 = 0 ;
50237 int res2 = 0 ;
50238 wxGBPosition temp3 ;
50239
50240 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50242 if (!SWIG_IsOK(res1)) {
50243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50244 }
50245 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50246 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50247 if (!SWIG_IsOK(res2)) {
50248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50249 }
50250 arg2 = reinterpret_cast< wxSizer * >(argp2);
50251 {
50252 arg3 = &temp3;
50253 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50254 }
50255 {
50256 PyThreadState* __tstate = wxPyBeginAllowThreads();
50257 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50258 wxPyEndAllowThreads(__tstate);
50259 if (PyErr_Occurred()) SWIG_fail;
50260 }
50261 {
50262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50263 }
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50271 PyObject *resultobj = 0;
50272 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50273 size_t arg2 ;
50274 wxGBPosition *arg3 = 0 ;
50275 bool result;
50276 void *argp1 = 0 ;
50277 int res1 = 0 ;
50278 size_t val2 ;
50279 int ecode2 = 0 ;
50280 wxGBPosition temp3 ;
50281
50282 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50284 if (!SWIG_IsOK(res1)) {
50285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50286 }
50287 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50288 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50289 if (!SWIG_IsOK(ecode2)) {
50290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50291 }
50292 arg2 = static_cast< size_t >(val2);
50293 {
50294 arg3 = &temp3;
50295 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50296 }
50297 {
50298 PyThreadState* __tstate = wxPyBeginAllowThreads();
50299 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50300 wxPyEndAllowThreads(__tstate);
50301 if (PyErr_Occurred()) SWIG_fail;
50302 }
50303 {
50304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50305 }
50306 return resultobj;
50307 fail:
50308 return NULL;
50309 }
50310
50311
50312 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50313 int argc;
50314 PyObject *argv[4];
50315
50316 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50317 --argc;
50318 if (argc == 3) {
50319 int _v = 0;
50320 {
50321 void *vptr = 0;
50322 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50323 _v = SWIG_CheckState(res);
50324 }
50325 if (!_v) goto check_1;
50326 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50327 }
50328 check_1:
50329
50330 if (argc == 3) {
50331 int _v = 0;
50332 {
50333 void *vptr = 0;
50334 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50335 _v = SWIG_CheckState(res);
50336 }
50337 if (!_v) goto check_2;
50338 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50339 }
50340 check_2:
50341
50342 if (argc == 3) {
50343 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50344 }
50345
50346 fail:
50347 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50348 return NULL;
50349 }
50350
50351
50352 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50353 PyObject *resultobj = 0;
50354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50355 wxWindow *arg2 = (wxWindow *) 0 ;
50356 wxGBSpan result;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 void *argp2 = 0 ;
50360 int res2 = 0 ;
50361
50362 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50364 if (!SWIG_IsOK(res1)) {
50365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50366 }
50367 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50368 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50369 if (!SWIG_IsOK(res2)) {
50370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50371 }
50372 arg2 = reinterpret_cast< wxWindow * >(argp2);
50373 {
50374 PyThreadState* __tstate = wxPyBeginAllowThreads();
50375 result = (arg1)->GetItemSpan(arg2);
50376 wxPyEndAllowThreads(__tstate);
50377 if (PyErr_Occurred()) SWIG_fail;
50378 }
50379 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50380 return resultobj;
50381 fail:
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50387 PyObject *resultobj = 0;
50388 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50389 wxSizer *arg2 = (wxSizer *) 0 ;
50390 wxGBSpan result;
50391 void *argp1 = 0 ;
50392 int res1 = 0 ;
50393 void *argp2 = 0 ;
50394 int res2 = 0 ;
50395
50396 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50398 if (!SWIG_IsOK(res1)) {
50399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50400 }
50401 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50403 if (!SWIG_IsOK(res2)) {
50404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50405 }
50406 arg2 = reinterpret_cast< wxSizer * >(argp2);
50407 {
50408 PyThreadState* __tstate = wxPyBeginAllowThreads();
50409 result = (arg1)->GetItemSpan(arg2);
50410 wxPyEndAllowThreads(__tstate);
50411 if (PyErr_Occurred()) SWIG_fail;
50412 }
50413 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50414 return resultobj;
50415 fail:
50416 return NULL;
50417 }
50418
50419
50420 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50421 PyObject *resultobj = 0;
50422 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50423 size_t arg2 ;
50424 wxGBSpan result;
50425 void *argp1 = 0 ;
50426 int res1 = 0 ;
50427 size_t val2 ;
50428 int ecode2 = 0 ;
50429
50430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50432 if (!SWIG_IsOK(res1)) {
50433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50434 }
50435 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50436 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50437 if (!SWIG_IsOK(ecode2)) {
50438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50439 }
50440 arg2 = static_cast< size_t >(val2);
50441 {
50442 PyThreadState* __tstate = wxPyBeginAllowThreads();
50443 result = (arg1)->GetItemSpan(arg2);
50444 wxPyEndAllowThreads(__tstate);
50445 if (PyErr_Occurred()) SWIG_fail;
50446 }
50447 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50455 int argc;
50456 PyObject *argv[3];
50457
50458 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50459 --argc;
50460 if (argc == 2) {
50461 int _v = 0;
50462 {
50463 void *vptr = 0;
50464 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50465 _v = SWIG_CheckState(res);
50466 }
50467 if (!_v) goto check_1;
50468 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50469 }
50470 check_1:
50471
50472 if (argc == 2) {
50473 int _v = 0;
50474 {
50475 void *vptr = 0;
50476 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50477 _v = SWIG_CheckState(res);
50478 }
50479 if (!_v) goto check_2;
50480 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50481 }
50482 check_2:
50483
50484 if (argc == 2) {
50485 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50486 }
50487
50488 fail:
50489 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50490 return NULL;
50491 }
50492
50493
50494 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50495 PyObject *resultobj = 0;
50496 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50497 wxWindow *arg2 = (wxWindow *) 0 ;
50498 wxGBSpan *arg3 = 0 ;
50499 bool result;
50500 void *argp1 = 0 ;
50501 int res1 = 0 ;
50502 void *argp2 = 0 ;
50503 int res2 = 0 ;
50504 wxGBSpan temp3 ;
50505
50506 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50508 if (!SWIG_IsOK(res1)) {
50509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50510 }
50511 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50512 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50513 if (!SWIG_IsOK(res2)) {
50514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50515 }
50516 arg2 = reinterpret_cast< wxWindow * >(argp2);
50517 {
50518 arg3 = &temp3;
50519 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50520 }
50521 {
50522 PyThreadState* __tstate = wxPyBeginAllowThreads();
50523 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50524 wxPyEndAllowThreads(__tstate);
50525 if (PyErr_Occurred()) SWIG_fail;
50526 }
50527 {
50528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50529 }
50530 return resultobj;
50531 fail:
50532 return NULL;
50533 }
50534
50535
50536 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50537 PyObject *resultobj = 0;
50538 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50539 wxSizer *arg2 = (wxSizer *) 0 ;
50540 wxGBSpan *arg3 = 0 ;
50541 bool result;
50542 void *argp1 = 0 ;
50543 int res1 = 0 ;
50544 void *argp2 = 0 ;
50545 int res2 = 0 ;
50546 wxGBSpan temp3 ;
50547
50548 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50550 if (!SWIG_IsOK(res1)) {
50551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50552 }
50553 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50554 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50555 if (!SWIG_IsOK(res2)) {
50556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50557 }
50558 arg2 = reinterpret_cast< wxSizer * >(argp2);
50559 {
50560 arg3 = &temp3;
50561 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50562 }
50563 {
50564 PyThreadState* __tstate = wxPyBeginAllowThreads();
50565 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50566 wxPyEndAllowThreads(__tstate);
50567 if (PyErr_Occurred()) SWIG_fail;
50568 }
50569 {
50570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50571 }
50572 return resultobj;
50573 fail:
50574 return NULL;
50575 }
50576
50577
50578 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50579 PyObject *resultobj = 0;
50580 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50581 size_t arg2 ;
50582 wxGBSpan *arg3 = 0 ;
50583 bool result;
50584 void *argp1 = 0 ;
50585 int res1 = 0 ;
50586 size_t val2 ;
50587 int ecode2 = 0 ;
50588 wxGBSpan temp3 ;
50589
50590 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50592 if (!SWIG_IsOK(res1)) {
50593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50594 }
50595 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50596 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50597 if (!SWIG_IsOK(ecode2)) {
50598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50599 }
50600 arg2 = static_cast< size_t >(val2);
50601 {
50602 arg3 = &temp3;
50603 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50604 }
50605 {
50606 PyThreadState* __tstate = wxPyBeginAllowThreads();
50607 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50608 wxPyEndAllowThreads(__tstate);
50609 if (PyErr_Occurred()) SWIG_fail;
50610 }
50611 {
50612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50613 }
50614 return resultobj;
50615 fail:
50616 return NULL;
50617 }
50618
50619
50620 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50621 int argc;
50622 PyObject *argv[4];
50623
50624 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50625 --argc;
50626 if (argc == 3) {
50627 int _v = 0;
50628 {
50629 void *vptr = 0;
50630 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50631 _v = SWIG_CheckState(res);
50632 }
50633 if (!_v) goto check_1;
50634 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50635 }
50636 check_1:
50637
50638 if (argc == 3) {
50639 int _v = 0;
50640 {
50641 void *vptr = 0;
50642 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50643 _v = SWIG_CheckState(res);
50644 }
50645 if (!_v) goto check_2;
50646 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50647 }
50648 check_2:
50649
50650 if (argc == 3) {
50651 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50652 }
50653
50654 fail:
50655 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50656 return NULL;
50657 }
50658
50659
50660 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50661 PyObject *resultobj = 0;
50662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50663 wxWindow *arg2 = (wxWindow *) 0 ;
50664 wxGBSizerItem *result = 0 ;
50665 void *argp1 = 0 ;
50666 int res1 = 0 ;
50667 void *argp2 = 0 ;
50668 int res2 = 0 ;
50669
50670 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50672 if (!SWIG_IsOK(res1)) {
50673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50674 }
50675 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50676 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50677 if (!SWIG_IsOK(res2)) {
50678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50679 }
50680 arg2 = reinterpret_cast< wxWindow * >(argp2);
50681 {
50682 PyThreadState* __tstate = wxPyBeginAllowThreads();
50683 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50684 wxPyEndAllowThreads(__tstate);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50688 return resultobj;
50689 fail:
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50695 PyObject *resultobj = 0;
50696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50697 wxSizer *arg2 = (wxSizer *) 0 ;
50698 wxGBSizerItem *result = 0 ;
50699 void *argp1 = 0 ;
50700 int res1 = 0 ;
50701 void *argp2 = 0 ;
50702 int res2 = 0 ;
50703
50704 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50708 }
50709 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50710 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50711 if (!SWIG_IsOK(res2)) {
50712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50713 }
50714 arg2 = reinterpret_cast< wxSizer * >(argp2);
50715 {
50716 PyThreadState* __tstate = wxPyBeginAllowThreads();
50717 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50718 wxPyEndAllowThreads(__tstate);
50719 if (PyErr_Occurred()) SWIG_fail;
50720 }
50721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50722 return resultobj;
50723 fail:
50724 return NULL;
50725 }
50726
50727
50728 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50729 int argc;
50730 PyObject *argv[3];
50731
50732 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50733 --argc;
50734 if (argc == 2) {
50735 int _v = 0;
50736 {
50737 void *vptr = 0;
50738 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50739 _v = SWIG_CheckState(res);
50740 }
50741 if (!_v) goto check_1;
50742 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50743 }
50744 check_1:
50745
50746 if (argc == 2) {
50747 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50748 }
50749
50750 fail:
50751 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50752 return NULL;
50753 }
50754
50755
50756 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50757 PyObject *resultobj = 0;
50758 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50759 wxGBPosition *arg2 = 0 ;
50760 wxGBSizerItem *result = 0 ;
50761 void *argp1 = 0 ;
50762 int res1 = 0 ;
50763 wxGBPosition temp2 ;
50764 PyObject * obj0 = 0 ;
50765 PyObject * obj1 = 0 ;
50766 char * kwnames[] = {
50767 (char *) "self",(char *) "pos", NULL
50768 };
50769
50770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50772 if (!SWIG_IsOK(res1)) {
50773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50774 }
50775 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50776 {
50777 arg2 = &temp2;
50778 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50779 }
50780 {
50781 PyThreadState* __tstate = wxPyBeginAllowThreads();
50782 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50783 wxPyEndAllowThreads(__tstate);
50784 if (PyErr_Occurred()) SWIG_fail;
50785 }
50786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50787 return resultobj;
50788 fail:
50789 return NULL;
50790 }
50791
50792
50793 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50794 PyObject *resultobj = 0;
50795 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50796 wxPoint *arg2 = 0 ;
50797 wxGBSizerItem *result = 0 ;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 wxPoint temp2 ;
50801 PyObject * obj0 = 0 ;
50802 PyObject * obj1 = 0 ;
50803 char * kwnames[] = {
50804 (char *) "self",(char *) "pt", NULL
50805 };
50806
50807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50809 if (!SWIG_IsOK(res1)) {
50810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50811 }
50812 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50813 {
50814 arg2 = &temp2;
50815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50816 }
50817 {
50818 PyThreadState* __tstate = wxPyBeginAllowThreads();
50819 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50820 wxPyEndAllowThreads(__tstate);
50821 if (PyErr_Occurred()) SWIG_fail;
50822 }
50823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50824 return resultobj;
50825 fail:
50826 return NULL;
50827 }
50828
50829
50830 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50831 PyObject *resultobj = 0;
50832 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50833 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50834 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50835 bool result;
50836 void *argp1 = 0 ;
50837 int res1 = 0 ;
50838 void *argp2 = 0 ;
50839 int res2 = 0 ;
50840 void *argp3 = 0 ;
50841 int res3 = 0 ;
50842 PyObject * obj0 = 0 ;
50843 PyObject * obj1 = 0 ;
50844 PyObject * obj2 = 0 ;
50845 char * kwnames[] = {
50846 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50847 };
50848
50849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50851 if (!SWIG_IsOK(res1)) {
50852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50853 }
50854 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50856 if (!SWIG_IsOK(res2)) {
50857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50858 }
50859 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50860 if (obj2) {
50861 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50862 if (!SWIG_IsOK(res3)) {
50863 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50864 }
50865 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50866 }
50867 {
50868 PyThreadState* __tstate = wxPyBeginAllowThreads();
50869 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50870 wxPyEndAllowThreads(__tstate);
50871 if (PyErr_Occurred()) SWIG_fail;
50872 }
50873 {
50874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50875 }
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50883 PyObject *resultobj = 0;
50884 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50885 wxGBPosition *arg2 = 0 ;
50886 wxGBSpan *arg3 = 0 ;
50887 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50888 bool result;
50889 void *argp1 = 0 ;
50890 int res1 = 0 ;
50891 wxGBPosition temp2 ;
50892 wxGBSpan temp3 ;
50893 void *argp4 = 0 ;
50894 int res4 = 0 ;
50895 PyObject * obj0 = 0 ;
50896 PyObject * obj1 = 0 ;
50897 PyObject * obj2 = 0 ;
50898 PyObject * obj3 = 0 ;
50899 char * kwnames[] = {
50900 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50901 };
50902
50903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50907 }
50908 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50909 {
50910 arg2 = &temp2;
50911 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50912 }
50913 {
50914 arg3 = &temp3;
50915 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50916 }
50917 if (obj3) {
50918 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50919 if (!SWIG_IsOK(res4)) {
50920 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50921 }
50922 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50923 }
50924 {
50925 PyThreadState* __tstate = wxPyBeginAllowThreads();
50926 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50927 wxPyEndAllowThreads(__tstate);
50928 if (PyErr_Occurred()) SWIG_fail;
50929 }
50930 {
50931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50932 }
50933 return resultobj;
50934 fail:
50935 return NULL;
50936 }
50937
50938
50939 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50940 PyObject *obj;
50941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50942 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50943 return SWIG_Py_Void();
50944 }
50945
50946 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50947 return SWIG_Python_InitShadowInstance(args);
50948 }
50949
50950 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50953 wxRelationship arg2 ;
50954 wxWindow *arg3 = (wxWindow *) 0 ;
50955 wxEdge arg4 ;
50956 int arg5 = (int) 0 ;
50957 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50958 void *argp1 = 0 ;
50959 int res1 = 0 ;
50960 int val2 ;
50961 int ecode2 = 0 ;
50962 void *argp3 = 0 ;
50963 int res3 = 0 ;
50964 int val4 ;
50965 int ecode4 = 0 ;
50966 int val5 ;
50967 int ecode5 = 0 ;
50968 int val6 ;
50969 int ecode6 = 0 ;
50970 PyObject * obj0 = 0 ;
50971 PyObject * obj1 = 0 ;
50972 PyObject * obj2 = 0 ;
50973 PyObject * obj3 = 0 ;
50974 PyObject * obj4 = 0 ;
50975 PyObject * obj5 = 0 ;
50976 char * kwnames[] = {
50977 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
50978 };
50979
50980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50982 if (!SWIG_IsOK(res1)) {
50983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50984 }
50985 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50986 ecode2 = SWIG_AsVal_int(obj1, &val2);
50987 if (!SWIG_IsOK(ecode2)) {
50988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
50989 }
50990 arg2 = static_cast< wxRelationship >(val2);
50991 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50992 if (!SWIG_IsOK(res3)) {
50993 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
50994 }
50995 arg3 = reinterpret_cast< wxWindow * >(argp3);
50996 ecode4 = SWIG_AsVal_int(obj3, &val4);
50997 if (!SWIG_IsOK(ecode4)) {
50998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
50999 }
51000 arg4 = static_cast< wxEdge >(val4);
51001 if (obj4) {
51002 ecode5 = SWIG_AsVal_int(obj4, &val5);
51003 if (!SWIG_IsOK(ecode5)) {
51004 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51005 }
51006 arg5 = static_cast< int >(val5);
51007 }
51008 if (obj5) {
51009 ecode6 = SWIG_AsVal_int(obj5, &val6);
51010 if (!SWIG_IsOK(ecode6)) {
51011 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51012 }
51013 arg6 = static_cast< int >(val6);
51014 }
51015 {
51016 PyThreadState* __tstate = wxPyBeginAllowThreads();
51017 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51018 wxPyEndAllowThreads(__tstate);
51019 if (PyErr_Occurred()) SWIG_fail;
51020 }
51021 resultobj = SWIG_Py_Void();
51022 return resultobj;
51023 fail:
51024 return NULL;
51025 }
51026
51027
51028 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51029 PyObject *resultobj = 0;
51030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51031 wxWindow *arg2 = (wxWindow *) 0 ;
51032 int arg3 = (int) 0 ;
51033 void *argp1 = 0 ;
51034 int res1 = 0 ;
51035 void *argp2 = 0 ;
51036 int res2 = 0 ;
51037 int val3 ;
51038 int ecode3 = 0 ;
51039 PyObject * obj0 = 0 ;
51040 PyObject * obj1 = 0 ;
51041 PyObject * obj2 = 0 ;
51042 char * kwnames[] = {
51043 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51044 };
51045
51046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51048 if (!SWIG_IsOK(res1)) {
51049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51050 }
51051 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51053 if (!SWIG_IsOK(res2)) {
51054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51055 }
51056 arg2 = reinterpret_cast< wxWindow * >(argp2);
51057 if (obj2) {
51058 ecode3 = SWIG_AsVal_int(obj2, &val3);
51059 if (!SWIG_IsOK(ecode3)) {
51060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51061 }
51062 arg3 = static_cast< int >(val3);
51063 }
51064 {
51065 PyThreadState* __tstate = wxPyBeginAllowThreads();
51066 (arg1)->LeftOf(arg2,arg3);
51067 wxPyEndAllowThreads(__tstate);
51068 if (PyErr_Occurred()) SWIG_fail;
51069 }
51070 resultobj = SWIG_Py_Void();
51071 return resultobj;
51072 fail:
51073 return NULL;
51074 }
51075
51076
51077 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51078 PyObject *resultobj = 0;
51079 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51080 wxWindow *arg2 = (wxWindow *) 0 ;
51081 int arg3 = (int) 0 ;
51082 void *argp1 = 0 ;
51083 int res1 = 0 ;
51084 void *argp2 = 0 ;
51085 int res2 = 0 ;
51086 int val3 ;
51087 int ecode3 = 0 ;
51088 PyObject * obj0 = 0 ;
51089 PyObject * obj1 = 0 ;
51090 PyObject * obj2 = 0 ;
51091 char * kwnames[] = {
51092 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51093 };
51094
51095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51097 if (!SWIG_IsOK(res1)) {
51098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51099 }
51100 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51102 if (!SWIG_IsOK(res2)) {
51103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51104 }
51105 arg2 = reinterpret_cast< wxWindow * >(argp2);
51106 if (obj2) {
51107 ecode3 = SWIG_AsVal_int(obj2, &val3);
51108 if (!SWIG_IsOK(ecode3)) {
51109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51110 }
51111 arg3 = static_cast< int >(val3);
51112 }
51113 {
51114 PyThreadState* __tstate = wxPyBeginAllowThreads();
51115 (arg1)->RightOf(arg2,arg3);
51116 wxPyEndAllowThreads(__tstate);
51117 if (PyErr_Occurred()) SWIG_fail;
51118 }
51119 resultobj = SWIG_Py_Void();
51120 return resultobj;
51121 fail:
51122 return NULL;
51123 }
51124
51125
51126 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51127 PyObject *resultobj = 0;
51128 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51129 wxWindow *arg2 = (wxWindow *) 0 ;
51130 int arg3 = (int) 0 ;
51131 void *argp1 = 0 ;
51132 int res1 = 0 ;
51133 void *argp2 = 0 ;
51134 int res2 = 0 ;
51135 int val3 ;
51136 int ecode3 = 0 ;
51137 PyObject * obj0 = 0 ;
51138 PyObject * obj1 = 0 ;
51139 PyObject * obj2 = 0 ;
51140 char * kwnames[] = {
51141 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51142 };
51143
51144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51146 if (!SWIG_IsOK(res1)) {
51147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51148 }
51149 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51151 if (!SWIG_IsOK(res2)) {
51152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51153 }
51154 arg2 = reinterpret_cast< wxWindow * >(argp2);
51155 if (obj2) {
51156 ecode3 = SWIG_AsVal_int(obj2, &val3);
51157 if (!SWIG_IsOK(ecode3)) {
51158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51159 }
51160 arg3 = static_cast< int >(val3);
51161 }
51162 {
51163 PyThreadState* __tstate = wxPyBeginAllowThreads();
51164 (arg1)->Above(arg2,arg3);
51165 wxPyEndAllowThreads(__tstate);
51166 if (PyErr_Occurred()) SWIG_fail;
51167 }
51168 resultobj = SWIG_Py_Void();
51169 return resultobj;
51170 fail:
51171 return NULL;
51172 }
51173
51174
51175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51176 PyObject *resultobj = 0;
51177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51178 wxWindow *arg2 = (wxWindow *) 0 ;
51179 int arg3 = (int) 0 ;
51180 void *argp1 = 0 ;
51181 int res1 = 0 ;
51182 void *argp2 = 0 ;
51183 int res2 = 0 ;
51184 int val3 ;
51185 int ecode3 = 0 ;
51186 PyObject * obj0 = 0 ;
51187 PyObject * obj1 = 0 ;
51188 PyObject * obj2 = 0 ;
51189 char * kwnames[] = {
51190 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51191 };
51192
51193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51197 }
51198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51200 if (!SWIG_IsOK(res2)) {
51201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51202 }
51203 arg2 = reinterpret_cast< wxWindow * >(argp2);
51204 if (obj2) {
51205 ecode3 = SWIG_AsVal_int(obj2, &val3);
51206 if (!SWIG_IsOK(ecode3)) {
51207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51208 }
51209 arg3 = static_cast< int >(val3);
51210 }
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 (arg1)->Below(arg2,arg3);
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_Py_Void();
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51227 wxWindow *arg2 = (wxWindow *) 0 ;
51228 wxEdge arg3 ;
51229 int arg4 = (int) 0 ;
51230 void *argp1 = 0 ;
51231 int res1 = 0 ;
51232 void *argp2 = 0 ;
51233 int res2 = 0 ;
51234 int val3 ;
51235 int ecode3 = 0 ;
51236 int val4 ;
51237 int ecode4 = 0 ;
51238 PyObject * obj0 = 0 ;
51239 PyObject * obj1 = 0 ;
51240 PyObject * obj2 = 0 ;
51241 PyObject * obj3 = 0 ;
51242 char * kwnames[] = {
51243 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51244 };
51245
51246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51250 }
51251 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51253 if (!SWIG_IsOK(res2)) {
51254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51255 }
51256 arg2 = reinterpret_cast< wxWindow * >(argp2);
51257 ecode3 = SWIG_AsVal_int(obj2, &val3);
51258 if (!SWIG_IsOK(ecode3)) {
51259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51260 }
51261 arg3 = static_cast< wxEdge >(val3);
51262 if (obj3) {
51263 ecode4 = SWIG_AsVal_int(obj3, &val4);
51264 if (!SWIG_IsOK(ecode4)) {
51265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51266 }
51267 arg4 = static_cast< int >(val4);
51268 }
51269 {
51270 PyThreadState* __tstate = wxPyBeginAllowThreads();
51271 (arg1)->SameAs(arg2,arg3,arg4);
51272 wxPyEndAllowThreads(__tstate);
51273 if (PyErr_Occurred()) SWIG_fail;
51274 }
51275 resultobj = SWIG_Py_Void();
51276 return resultobj;
51277 fail:
51278 return NULL;
51279 }
51280
51281
51282 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51283 PyObject *resultobj = 0;
51284 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51285 wxWindow *arg2 = (wxWindow *) 0 ;
51286 wxEdge arg3 ;
51287 int arg4 ;
51288 void *argp1 = 0 ;
51289 int res1 = 0 ;
51290 void *argp2 = 0 ;
51291 int res2 = 0 ;
51292 int val3 ;
51293 int ecode3 = 0 ;
51294 int val4 ;
51295 int ecode4 = 0 ;
51296 PyObject * obj0 = 0 ;
51297 PyObject * obj1 = 0 ;
51298 PyObject * obj2 = 0 ;
51299 PyObject * obj3 = 0 ;
51300 char * kwnames[] = {
51301 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51302 };
51303
51304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51306 if (!SWIG_IsOK(res1)) {
51307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51308 }
51309 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51311 if (!SWIG_IsOK(res2)) {
51312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51313 }
51314 arg2 = reinterpret_cast< wxWindow * >(argp2);
51315 ecode3 = SWIG_AsVal_int(obj2, &val3);
51316 if (!SWIG_IsOK(ecode3)) {
51317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51318 }
51319 arg3 = static_cast< wxEdge >(val3);
51320 ecode4 = SWIG_AsVal_int(obj3, &val4);
51321 if (!SWIG_IsOK(ecode4)) {
51322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51323 }
51324 arg4 = static_cast< int >(val4);
51325 {
51326 PyThreadState* __tstate = wxPyBeginAllowThreads();
51327 (arg1)->PercentOf(arg2,arg3,arg4);
51328 wxPyEndAllowThreads(__tstate);
51329 if (PyErr_Occurred()) SWIG_fail;
51330 }
51331 resultobj = SWIG_Py_Void();
51332 return resultobj;
51333 fail:
51334 return NULL;
51335 }
51336
51337
51338 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51339 PyObject *resultobj = 0;
51340 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51341 int arg2 ;
51342 void *argp1 = 0 ;
51343 int res1 = 0 ;
51344 int val2 ;
51345 int ecode2 = 0 ;
51346 PyObject * obj0 = 0 ;
51347 PyObject * obj1 = 0 ;
51348 char * kwnames[] = {
51349 (char *) "self",(char *) "val", NULL
51350 };
51351
51352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51354 if (!SWIG_IsOK(res1)) {
51355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51356 }
51357 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51358 ecode2 = SWIG_AsVal_int(obj1, &val2);
51359 if (!SWIG_IsOK(ecode2)) {
51360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51361 }
51362 arg2 = static_cast< int >(val2);
51363 {
51364 PyThreadState* __tstate = wxPyBeginAllowThreads();
51365 (arg1)->Absolute(arg2);
51366 wxPyEndAllowThreads(__tstate);
51367 if (PyErr_Occurred()) SWIG_fail;
51368 }
51369 resultobj = SWIG_Py_Void();
51370 return resultobj;
51371 fail:
51372 return NULL;
51373 }
51374
51375
51376 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51377 PyObject *resultobj = 0;
51378 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51379 void *argp1 = 0 ;
51380 int res1 = 0 ;
51381 PyObject *swig_obj[1] ;
51382
51383 if (!args) SWIG_fail;
51384 swig_obj[0] = args;
51385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51386 if (!SWIG_IsOK(res1)) {
51387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51388 }
51389 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51390 {
51391 PyThreadState* __tstate = wxPyBeginAllowThreads();
51392 (arg1)->Unconstrained();
51393 wxPyEndAllowThreads(__tstate);
51394 if (PyErr_Occurred()) SWIG_fail;
51395 }
51396 resultobj = SWIG_Py_Void();
51397 return resultobj;
51398 fail:
51399 return NULL;
51400 }
51401
51402
51403 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51404 PyObject *resultobj = 0;
51405 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51406 void *argp1 = 0 ;
51407 int res1 = 0 ;
51408 PyObject *swig_obj[1] ;
51409
51410 if (!args) SWIG_fail;
51411 swig_obj[0] = args;
51412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51413 if (!SWIG_IsOK(res1)) {
51414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51415 }
51416 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51417 {
51418 PyThreadState* __tstate = wxPyBeginAllowThreads();
51419 (arg1)->AsIs();
51420 wxPyEndAllowThreads(__tstate);
51421 if (PyErr_Occurred()) SWIG_fail;
51422 }
51423 resultobj = SWIG_Py_Void();
51424 return resultobj;
51425 fail:
51426 return NULL;
51427 }
51428
51429
51430 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51431 PyObject *resultobj = 0;
51432 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51433 wxWindow *result = 0 ;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 PyObject *swig_obj[1] ;
51437
51438 if (!args) SWIG_fail;
51439 swig_obj[0] = args;
51440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51443 }
51444 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51445 {
51446 PyThreadState* __tstate = wxPyBeginAllowThreads();
51447 result = (wxWindow *)(arg1)->GetOtherWindow();
51448 wxPyEndAllowThreads(__tstate);
51449 if (PyErr_Occurred()) SWIG_fail;
51450 }
51451 {
51452 resultobj = wxPyMake_wxObject(result, 0);
51453 }
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51461 PyObject *resultobj = 0;
51462 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51463 wxEdge result;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 PyObject *swig_obj[1] ;
51467
51468 if (!args) SWIG_fail;
51469 swig_obj[0] = args;
51470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51471 if (!SWIG_IsOK(res1)) {
51472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51473 }
51474 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51475 {
51476 PyThreadState* __tstate = wxPyBeginAllowThreads();
51477 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51478 wxPyEndAllowThreads(__tstate);
51479 if (PyErr_Occurred()) SWIG_fail;
51480 }
51481 resultobj = SWIG_From_int(static_cast< int >(result));
51482 return resultobj;
51483 fail:
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51489 PyObject *resultobj = 0;
51490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51491 wxEdge arg2 ;
51492 void *argp1 = 0 ;
51493 int res1 = 0 ;
51494 int val2 ;
51495 int ecode2 = 0 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 char * kwnames[] = {
51499 (char *) "self",(char *) "which", NULL
51500 };
51501
51502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51504 if (!SWIG_IsOK(res1)) {
51505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51506 }
51507 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51508 ecode2 = SWIG_AsVal_int(obj1, &val2);
51509 if (!SWIG_IsOK(ecode2)) {
51510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51511 }
51512 arg2 = static_cast< wxEdge >(val2);
51513 {
51514 PyThreadState* __tstate = wxPyBeginAllowThreads();
51515 (arg1)->SetEdge(arg2);
51516 wxPyEndAllowThreads(__tstate);
51517 if (PyErr_Occurred()) SWIG_fail;
51518 }
51519 resultobj = SWIG_Py_Void();
51520 return resultobj;
51521 fail:
51522 return NULL;
51523 }
51524
51525
51526 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51527 PyObject *resultobj = 0;
51528 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51529 int arg2 ;
51530 void *argp1 = 0 ;
51531 int res1 = 0 ;
51532 int val2 ;
51533 int ecode2 = 0 ;
51534 PyObject * obj0 = 0 ;
51535 PyObject * obj1 = 0 ;
51536 char * kwnames[] = {
51537 (char *) "self",(char *) "v", NULL
51538 };
51539
51540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51542 if (!SWIG_IsOK(res1)) {
51543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51544 }
51545 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51546 ecode2 = SWIG_AsVal_int(obj1, &val2);
51547 if (!SWIG_IsOK(ecode2)) {
51548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51549 }
51550 arg2 = static_cast< int >(val2);
51551 {
51552 PyThreadState* __tstate = wxPyBeginAllowThreads();
51553 (arg1)->SetValue(arg2);
51554 wxPyEndAllowThreads(__tstate);
51555 if (PyErr_Occurred()) SWIG_fail;
51556 }
51557 resultobj = SWIG_Py_Void();
51558 return resultobj;
51559 fail:
51560 return NULL;
51561 }
51562
51563
51564 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51565 PyObject *resultobj = 0;
51566 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51567 int result;
51568 void *argp1 = 0 ;
51569 int res1 = 0 ;
51570 PyObject *swig_obj[1] ;
51571
51572 if (!args) SWIG_fail;
51573 swig_obj[0] = args;
51574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51575 if (!SWIG_IsOK(res1)) {
51576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51577 }
51578 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51579 {
51580 PyThreadState* __tstate = wxPyBeginAllowThreads();
51581 result = (int)(arg1)->GetMargin();
51582 wxPyEndAllowThreads(__tstate);
51583 if (PyErr_Occurred()) SWIG_fail;
51584 }
51585 resultobj = SWIG_From_int(static_cast< int >(result));
51586 return resultobj;
51587 fail:
51588 return NULL;
51589 }
51590
51591
51592 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51593 PyObject *resultobj = 0;
51594 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51595 int arg2 ;
51596 void *argp1 = 0 ;
51597 int res1 = 0 ;
51598 int val2 ;
51599 int ecode2 = 0 ;
51600 PyObject * obj0 = 0 ;
51601 PyObject * obj1 = 0 ;
51602 char * kwnames[] = {
51603 (char *) "self",(char *) "m", NULL
51604 };
51605
51606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51608 if (!SWIG_IsOK(res1)) {
51609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51610 }
51611 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51612 ecode2 = SWIG_AsVal_int(obj1, &val2);
51613 if (!SWIG_IsOK(ecode2)) {
51614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51615 }
51616 arg2 = static_cast< int >(val2);
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 (arg1)->SetMargin(arg2);
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 resultobj = SWIG_Py_Void();
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51633 int result;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 PyObject *swig_obj[1] ;
51637
51638 if (!args) SWIG_fail;
51639 swig_obj[0] = args;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51643 }
51644 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_From_int(static_cast< int >(result));
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *resultobj = 0;
51660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51661 int result;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 PyObject *swig_obj[1] ;
51665
51666 if (!args) SWIG_fail;
51667 swig_obj[0] = args;
51668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51669 if (!SWIG_IsOK(res1)) {
51670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51671 }
51672 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51673 {
51674 PyThreadState* __tstate = wxPyBeginAllowThreads();
51675 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51676 wxPyEndAllowThreads(__tstate);
51677 if (PyErr_Occurred()) SWIG_fail;
51678 }
51679 resultobj = SWIG_From_int(static_cast< int >(result));
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51687 PyObject *resultobj = 0;
51688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51689 int result;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 PyObject *swig_obj[1] ;
51693
51694 if (!args) SWIG_fail;
51695 swig_obj[0] = args;
51696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51699 }
51700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51701 {
51702 PyThreadState* __tstate = wxPyBeginAllowThreads();
51703 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51704 wxPyEndAllowThreads(__tstate);
51705 if (PyErr_Occurred()) SWIG_fail;
51706 }
51707 resultobj = SWIG_From_int(static_cast< int >(result));
51708 return resultobj;
51709 fail:
51710 return NULL;
51711 }
51712
51713
51714 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51715 PyObject *resultobj = 0;
51716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51717 bool result;
51718 void *argp1 = 0 ;
51719 int res1 = 0 ;
51720 PyObject *swig_obj[1] ;
51721
51722 if (!args) SWIG_fail;
51723 swig_obj[0] = args;
51724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51725 if (!SWIG_IsOK(res1)) {
51726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51727 }
51728 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51729 {
51730 PyThreadState* __tstate = wxPyBeginAllowThreads();
51731 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51732 wxPyEndAllowThreads(__tstate);
51733 if (PyErr_Occurred()) SWIG_fail;
51734 }
51735 {
51736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51737 }
51738 return resultobj;
51739 fail:
51740 return NULL;
51741 }
51742
51743
51744 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51745 PyObject *resultobj = 0;
51746 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51747 bool arg2 ;
51748 void *argp1 = 0 ;
51749 int res1 = 0 ;
51750 bool val2 ;
51751 int ecode2 = 0 ;
51752 PyObject * obj0 = 0 ;
51753 PyObject * obj1 = 0 ;
51754 char * kwnames[] = {
51755 (char *) "self",(char *) "d", NULL
51756 };
51757
51758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51760 if (!SWIG_IsOK(res1)) {
51761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51762 }
51763 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51765 if (!SWIG_IsOK(ecode2)) {
51766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51767 }
51768 arg2 = static_cast< bool >(val2);
51769 {
51770 PyThreadState* __tstate = wxPyBeginAllowThreads();
51771 (arg1)->SetDone(arg2);
51772 wxPyEndAllowThreads(__tstate);
51773 if (PyErr_Occurred()) SWIG_fail;
51774 }
51775 resultobj = SWIG_Py_Void();
51776 return resultobj;
51777 fail:
51778 return NULL;
51779 }
51780
51781
51782 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51783 PyObject *resultobj = 0;
51784 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51785 wxRelationship result;
51786 void *argp1 = 0 ;
51787 int res1 = 0 ;
51788 PyObject *swig_obj[1] ;
51789
51790 if (!args) SWIG_fail;
51791 swig_obj[0] = args;
51792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51793 if (!SWIG_IsOK(res1)) {
51794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51795 }
51796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (wxRelationship)(arg1)->GetRelationship();
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_From_int(static_cast< int >(result));
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51811 PyObject *resultobj = 0;
51812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51813 wxRelationship arg2 ;
51814 void *argp1 = 0 ;
51815 int res1 = 0 ;
51816 int val2 ;
51817 int ecode2 = 0 ;
51818 PyObject * obj0 = 0 ;
51819 PyObject * obj1 = 0 ;
51820 char * kwnames[] = {
51821 (char *) "self",(char *) "r", NULL
51822 };
51823
51824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51826 if (!SWIG_IsOK(res1)) {
51827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51828 }
51829 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51830 ecode2 = SWIG_AsVal_int(obj1, &val2);
51831 if (!SWIG_IsOK(ecode2)) {
51832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51833 }
51834 arg2 = static_cast< wxRelationship >(val2);
51835 {
51836 PyThreadState* __tstate = wxPyBeginAllowThreads();
51837 (arg1)->SetRelationship(arg2);
51838 wxPyEndAllowThreads(__tstate);
51839 if (PyErr_Occurred()) SWIG_fail;
51840 }
51841 resultobj = SWIG_Py_Void();
51842 return resultobj;
51843 fail:
51844 return NULL;
51845 }
51846
51847
51848 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51849 PyObject *resultobj = 0;
51850 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51851 wxWindow *arg2 = (wxWindow *) 0 ;
51852 bool result;
51853 void *argp1 = 0 ;
51854 int res1 = 0 ;
51855 void *argp2 = 0 ;
51856 int res2 = 0 ;
51857 PyObject * obj0 = 0 ;
51858 PyObject * obj1 = 0 ;
51859 char * kwnames[] = {
51860 (char *) "self",(char *) "otherW", NULL
51861 };
51862
51863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51865 if (!SWIG_IsOK(res1)) {
51866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51867 }
51868 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51870 if (!SWIG_IsOK(res2)) {
51871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51872 }
51873 arg2 = reinterpret_cast< wxWindow * >(argp2);
51874 {
51875 PyThreadState* __tstate = wxPyBeginAllowThreads();
51876 result = (bool)(arg1)->ResetIfWin(arg2);
51877 wxPyEndAllowThreads(__tstate);
51878 if (PyErr_Occurred()) SWIG_fail;
51879 }
51880 {
51881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51882 }
51883 return resultobj;
51884 fail:
51885 return NULL;
51886 }
51887
51888
51889 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51890 PyObject *resultobj = 0;
51891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51892 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51893 wxWindow *arg3 = (wxWindow *) 0 ;
51894 bool result;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 void *argp2 = 0 ;
51898 int res2 = 0 ;
51899 void *argp3 = 0 ;
51900 int res3 = 0 ;
51901 PyObject * obj0 = 0 ;
51902 PyObject * obj1 = 0 ;
51903 PyObject * obj2 = 0 ;
51904 char * kwnames[] = {
51905 (char *) "self",(char *) "constraints",(char *) "win", NULL
51906 };
51907
51908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51910 if (!SWIG_IsOK(res1)) {
51911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51912 }
51913 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51915 if (!SWIG_IsOK(res2)) {
51916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51917 }
51918 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51919 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51920 if (!SWIG_IsOK(res3)) {
51921 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51922 }
51923 arg3 = reinterpret_cast< wxWindow * >(argp3);
51924 {
51925 PyThreadState* __tstate = wxPyBeginAllowThreads();
51926 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51927 wxPyEndAllowThreads(__tstate);
51928 if (PyErr_Occurred()) SWIG_fail;
51929 }
51930 {
51931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51932 }
51933 return resultobj;
51934 fail:
51935 return NULL;
51936 }
51937
51938
51939 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51940 PyObject *resultobj = 0;
51941 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51942 wxEdge arg2 ;
51943 wxWindow *arg3 = (wxWindow *) 0 ;
51944 wxWindow *arg4 = (wxWindow *) 0 ;
51945 int result;
51946 void *argp1 = 0 ;
51947 int res1 = 0 ;
51948 int val2 ;
51949 int ecode2 = 0 ;
51950 void *argp3 = 0 ;
51951 int res3 = 0 ;
51952 void *argp4 = 0 ;
51953 int res4 = 0 ;
51954 PyObject * obj0 = 0 ;
51955 PyObject * obj1 = 0 ;
51956 PyObject * obj2 = 0 ;
51957 PyObject * obj3 = 0 ;
51958 char * kwnames[] = {
51959 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51960 };
51961
51962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51964 if (!SWIG_IsOK(res1)) {
51965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51966 }
51967 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51968 ecode2 = SWIG_AsVal_int(obj1, &val2);
51969 if (!SWIG_IsOK(ecode2)) {
51970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51971 }
51972 arg2 = static_cast< wxEdge >(val2);
51973 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51974 if (!SWIG_IsOK(res3)) {
51975 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
51976 }
51977 arg3 = reinterpret_cast< wxWindow * >(argp3);
51978 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
51979 if (!SWIG_IsOK(res4)) {
51980 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
51981 }
51982 arg4 = reinterpret_cast< wxWindow * >(argp4);
51983 {
51984 PyThreadState* __tstate = wxPyBeginAllowThreads();
51985 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
51986 wxPyEndAllowThreads(__tstate);
51987 if (PyErr_Occurred()) SWIG_fail;
51988 }
51989 resultobj = SWIG_From_int(static_cast< int >(result));
51990 return resultobj;
51991 fail:
51992 return NULL;
51993 }
51994
51995
51996 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51997 PyObject *obj;
51998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51999 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52000 return SWIG_Py_Void();
52001 }
52002
52003 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52004 PyObject *resultobj = 0;
52005 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52006 wxIndividualLayoutConstraint *result = 0 ;
52007 void *argp1 = 0 ;
52008 int res1 = 0 ;
52009 PyObject *swig_obj[1] ;
52010
52011 if (!args) SWIG_fail;
52012 swig_obj[0] = args;
52013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52014 if (!SWIG_IsOK(res1)) {
52015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52016 }
52017 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52018 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52020 return resultobj;
52021 fail:
52022 return NULL;
52023 }
52024
52025
52026 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52027 PyObject *resultobj = 0;
52028 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52029 wxIndividualLayoutConstraint *result = 0 ;
52030 void *argp1 = 0 ;
52031 int res1 = 0 ;
52032 PyObject *swig_obj[1] ;
52033
52034 if (!args) SWIG_fail;
52035 swig_obj[0] = args;
52036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52037 if (!SWIG_IsOK(res1)) {
52038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52039 }
52040 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52041 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52043 return resultobj;
52044 fail:
52045 return NULL;
52046 }
52047
52048
52049 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52050 PyObject *resultobj = 0;
52051 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52052 wxIndividualLayoutConstraint *result = 0 ;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 PyObject *swig_obj[1] ;
52056
52057 if (!args) SWIG_fail;
52058 swig_obj[0] = args;
52059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52060 if (!SWIG_IsOK(res1)) {
52061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52062 }
52063 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52064 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52066 return resultobj;
52067 fail:
52068 return NULL;
52069 }
52070
52071
52072 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52073 PyObject *resultobj = 0;
52074 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52075 wxIndividualLayoutConstraint *result = 0 ;
52076 void *argp1 = 0 ;
52077 int res1 = 0 ;
52078 PyObject *swig_obj[1] ;
52079
52080 if (!args) SWIG_fail;
52081 swig_obj[0] = args;
52082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52083 if (!SWIG_IsOK(res1)) {
52084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52085 }
52086 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52087 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52089 return resultobj;
52090 fail:
52091 return NULL;
52092 }
52093
52094
52095 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52096 PyObject *resultobj = 0;
52097 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52098 wxIndividualLayoutConstraint *result = 0 ;
52099 void *argp1 = 0 ;
52100 int res1 = 0 ;
52101 PyObject *swig_obj[1] ;
52102
52103 if (!args) SWIG_fail;
52104 swig_obj[0] = args;
52105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52106 if (!SWIG_IsOK(res1)) {
52107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52108 }
52109 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52110 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52112 return resultobj;
52113 fail:
52114 return NULL;
52115 }
52116
52117
52118 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52119 PyObject *resultobj = 0;
52120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52121 wxIndividualLayoutConstraint *result = 0 ;
52122 void *argp1 = 0 ;
52123 int res1 = 0 ;
52124 PyObject *swig_obj[1] ;
52125
52126 if (!args) SWIG_fail;
52127 swig_obj[0] = args;
52128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52129 if (!SWIG_IsOK(res1)) {
52130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52131 }
52132 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52133 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52142 PyObject *resultobj = 0;
52143 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52144 wxIndividualLayoutConstraint *result = 0 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 PyObject *swig_obj[1] ;
52148
52149 if (!args) SWIG_fail;
52150 swig_obj[0] = args;
52151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52154 }
52155 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52156 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52158 return resultobj;
52159 fail:
52160 return NULL;
52161 }
52162
52163
52164 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52165 PyObject *resultobj = 0;
52166 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52167 wxIndividualLayoutConstraint *result = 0 ;
52168 void *argp1 = 0 ;
52169 int res1 = 0 ;
52170 PyObject *swig_obj[1] ;
52171
52172 if (!args) SWIG_fail;
52173 swig_obj[0] = args;
52174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52175 if (!SWIG_IsOK(res1)) {
52176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52177 }
52178 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52179 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52181 return resultobj;
52182 fail:
52183 return NULL;
52184 }
52185
52186
52187 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52188 PyObject *resultobj = 0;
52189 wxLayoutConstraints *result = 0 ;
52190
52191 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52192 {
52193 PyThreadState* __tstate = wxPyBeginAllowThreads();
52194 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52195 wxPyEndAllowThreads(__tstate);
52196 if (PyErr_Occurred()) SWIG_fail;
52197 }
52198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52199 return resultobj;
52200 fail:
52201 return NULL;
52202 }
52203
52204
52205 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52206 PyObject *resultobj = 0;
52207 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52208 void *argp1 = 0 ;
52209 int res1 = 0 ;
52210 PyObject *swig_obj[1] ;
52211
52212 if (!args) SWIG_fail;
52213 swig_obj[0] = args;
52214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52215 if (!SWIG_IsOK(res1)) {
52216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52217 }
52218 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52219 {
52220 PyThreadState* __tstate = wxPyBeginAllowThreads();
52221 delete arg1;
52222
52223 wxPyEndAllowThreads(__tstate);
52224 if (PyErr_Occurred()) SWIG_fail;
52225 }
52226 resultobj = SWIG_Py_Void();
52227 return resultobj;
52228 fail:
52229 return NULL;
52230 }
52231
52232
52233 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52234 PyObject *resultobj = 0;
52235 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52236 wxWindow *arg2 = (wxWindow *) 0 ;
52237 int *arg3 = (int *) 0 ;
52238 bool result;
52239 void *argp1 = 0 ;
52240 int res1 = 0 ;
52241 void *argp2 = 0 ;
52242 int res2 = 0 ;
52243 int temp3 ;
52244 int res3 = SWIG_TMPOBJ ;
52245 PyObject * obj0 = 0 ;
52246 PyObject * obj1 = 0 ;
52247 char * kwnames[] = {
52248 (char *) "self",(char *) "win", NULL
52249 };
52250
52251 arg3 = &temp3;
52252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52256 }
52257 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52259 if (!SWIG_IsOK(res2)) {
52260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52261 }
52262 arg2 = reinterpret_cast< wxWindow * >(argp2);
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 {
52270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52271 }
52272 if (SWIG_IsTmpObj(res3)) {
52273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52274 } else {
52275 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52277 }
52278 return resultobj;
52279 fail:
52280 return NULL;
52281 }
52282
52283
52284 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52285 PyObject *resultobj = 0;
52286 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52287 bool result;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 PyObject *swig_obj[1] ;
52291
52292 if (!args) SWIG_fail;
52293 swig_obj[0] = args;
52294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52295 if (!SWIG_IsOK(res1)) {
52296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52297 }
52298 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52299 {
52300 PyThreadState* __tstate = wxPyBeginAllowThreads();
52301 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52302 wxPyEndAllowThreads(__tstate);
52303 if (PyErr_Occurred()) SWIG_fail;
52304 }
52305 {
52306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52307 }
52308 return resultobj;
52309 fail:
52310 return NULL;
52311 }
52312
52313
52314 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52315 PyObject *obj;
52316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52317 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52318 return SWIG_Py_Void();
52319 }
52320
52321 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52322 return SWIG_Python_InitShadowInstance(args);
52323 }
52324
52325 static PyMethodDef SwigMethods[] = {
52326 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52327 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52328 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52329 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52330 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52331 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52332 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52333 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52334 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52335 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52336 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52337 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52338 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52339 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52340 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52341 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52342 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52343 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52344 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52345 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52346 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52347 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52348 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52349 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52350 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52351 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52352 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52353 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52354 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52355 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52356 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52357 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52358 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52359 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52360 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52361 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52362 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52363 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52365 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52366 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52367 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52368 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52369 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52370 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52371 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52373 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52375 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52377 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52378 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52379 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52380 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52381 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52382 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52383 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52384 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52385 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52387 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52388 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52389 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52390 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52391 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52392 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52393 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52394 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52395 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52396 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52397 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52399 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52401 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52402 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52404 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52406 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52407 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52408 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52409 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52417 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52419 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52421 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52423 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52425 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52427 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52428 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52429 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52430 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52431 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52432 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52433 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52434 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52435 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52436 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52437 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52438 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52439 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52444 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52445 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52446 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52447 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52449 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52451 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52454 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52456 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52459 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52460 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52461 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52462 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52463 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52464 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52465 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52466 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52467 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52468 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52470 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52471 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52472 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52473 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52474 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52475 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52478 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52479 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52480 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52481 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52482 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52483 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52486 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52487 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52488 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52490 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52491 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52493 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52494 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52495 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52496 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52497 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52498 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52499 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52500 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52501 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52502 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52507 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52513 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52514 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52515 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52516 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52518 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52521 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52523 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52526 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52527 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52528 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52531 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52532 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52533 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52537 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52538 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52539 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52543 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52548 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52549 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52550 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52551 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52552 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52553 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52554 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52560 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52561 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52563 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52564 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52565 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52571 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52572 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52574 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52575 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52576 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52577 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52578 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52579 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52580 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52581 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52583 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52584 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52585 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52586 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52587 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52588 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52589 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52590 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52592 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52601 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52613 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52614 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52629 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52630 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52631 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52632 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52635 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52637 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52639 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52641 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52643 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52646 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52647 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52648 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52649 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52651 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52668 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52669 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52675 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52676 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52677 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52678 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52679 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52680 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52681 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52682 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52683 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52684 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52685 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52686 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52687 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52688 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52689 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52690 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52691 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52692 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52693 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52694 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52695 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52696 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52697 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52698 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52699 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52700 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52701 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52702 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52703 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52704 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52705 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52706 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52707 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52708 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52709 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52711 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52712 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52713 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52714 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52717 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52721 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52725 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52726 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52727 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52728 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52730 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52731 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52733 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52735 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52737 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52739 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52740 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52741 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52743 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52744 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52746 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52747 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52748 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52750 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52751 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52752 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52754 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52756 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52757 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52758 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52760 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52762 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52763 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52765 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52766 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52767 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52769 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52770 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52771 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52772 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52773 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52775 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52776 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52779 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52780 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52782 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52783 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52786 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52787 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52789 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52795 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52796 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52797 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52798 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52799 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52800 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52801 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52802 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52803 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52804 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52805 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52806 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52807 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52808 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52809 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52810 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52811 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52812 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52813 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52814 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52815 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52816 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52817 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52818 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52820 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52821 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52822 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52823 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52824 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52825 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52826 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52827 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52828 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52829 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52830 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52831 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52832 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52833 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52834 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52835 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52836 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52837 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52838 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52839 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52840 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52841 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52842 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52843 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52844 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52845 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52846 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52847 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52848 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52849 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52850 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52851 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52853 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52854 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52856 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52857 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52858 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52859 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52861 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52862 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52863 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52864 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52865 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52866 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52867 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52868 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52869 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52870 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52871 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52872 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52873 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52874 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52875 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52876 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52877 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52878 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52879 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52880 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52881 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52882 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52883 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52884 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52885 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52886 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52887 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52888 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52889 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52890 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52891 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52892 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52893 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52894 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52895 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52896 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52897 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52899 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52900 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52903 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52904 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52905 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52906 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52907 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52908 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52910 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52911 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52914 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52915 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52917 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52918 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52920 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52921 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52923 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52924 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52925 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52927 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52929 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52930 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52932 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52933 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52934 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52936 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52937 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52938 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52940 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52941 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52943 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52944 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52945 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52946 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52947 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52950 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52952 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52954 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52955 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52956 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52959 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52960 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52961 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52963 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52964 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52965 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52967 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52968 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52969 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52970 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52971 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52972 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
52974 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
52975 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
52976 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
52977 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
52978 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
52979 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
52980 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
52981 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
52987 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
52989 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
52991 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
52992 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
52993 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
52994 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
52995 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
52996 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
52998 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
52999 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53000 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53001 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53002 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53003 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53006 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53007 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53008 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53011 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53012 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53014 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53015 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53017 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53019 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53022 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53024 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53025 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53027 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53028 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53031 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53032 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53033 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53035 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53037 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53038 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53039 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53041 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53043 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53045 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53046 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53048 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53050 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53051 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53052 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53054 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53056 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53057 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53058 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53060 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53062 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53063 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53064 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53065 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53067 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53069 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53071 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53073 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53074 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53076 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53077 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53078 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53079 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53080 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53081 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53082 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53083 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53085 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53087 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53089 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53091 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53093 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53095 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53096 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53097 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53098 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53099 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53100 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53106 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53107 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53108 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53109 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53110 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53111 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53112 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53114 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53116 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53117 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53119 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53120 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53121 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53122 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53124 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53125 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53126 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53127 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53129 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53130 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53132 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53133 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53136 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53138 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53139 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53140 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53141 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53142 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53144 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53145 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53146 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53147 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53149 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53150 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53151 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53152 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53153 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53154 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53155 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53156 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53157 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53158 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53160 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53163 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53164 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53165 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53167 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53169 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53171 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53173 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53174 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53184 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53185 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53189 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53190 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53191 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53192 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53193 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53194 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53195 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53196 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53197 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53198 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53199 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53200 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53201 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53202 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53203 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53205 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53206 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53209 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53210 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53215 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53216 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53219 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53220 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53221 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53222 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53225 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53226 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53227 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53229 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53231 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53232 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53233 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53235 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53237 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53239 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53242 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53243 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53244 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53245 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53246 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53247 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53248 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53254 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53255 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53256 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53257 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53263 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53269 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53270 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53271 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53272 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53273 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53275 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53285 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53286 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53287 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53288 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53291 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53292 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53293 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53294 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53296 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53297 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53301 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53307 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53308 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53309 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53310 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53312 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53313 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53315 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53318 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53320 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53321 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53322 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53331 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53335 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53337 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53347 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53348 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53349 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53350 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53353 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53356 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53358 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53361 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53363 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53364 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53367 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53369 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53370 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53371 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53372 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53373 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53378 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53379 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53380 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53382 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53383 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53384 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53386 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53388 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53389 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53390 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53392 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53393 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53396 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53403 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53410 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53418 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53421 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53422 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53435 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53437 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53439 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53440 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53442 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53444 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53445 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53447 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53448 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53449 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53453 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53472 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53473 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53475 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53477 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53478 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53479 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53481 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53482 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53485 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53486 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53488 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53489 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53491 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53494 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53495 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53497 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53499 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53501 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53502 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53504 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53505 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53508 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53510 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53512 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53514 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53517 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53519 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53520 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53521 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53523 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53524 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53525 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53527 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53530 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53532 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53533 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53537 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53541 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53542 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53544 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53548 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53550 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53552 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53553 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53554 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53555 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53559 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53560 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53561 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53562 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53564 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53565 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53570 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53571 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53572 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53573 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53574 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53576 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53578 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53580 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53581 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53583 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53585 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53588 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53589 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53590 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53592 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53593 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53594 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53608 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53609 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53610 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53611 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53612 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53613 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53619 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53620 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53624 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53625 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53627 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53628 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53630 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53632 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53633 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53635 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53636 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53637 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53643 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53644 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53645 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53646 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53647 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53648 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53655 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53657 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53658 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53659 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53660 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53661 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53662 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53664 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53668 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53669 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53670 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53671 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53672 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53673 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53674 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53676 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53677 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53678 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53684 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53685 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53686 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53688 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53689 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53690 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53696 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53697 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53698 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53699 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53700 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53704 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53705 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53710 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53711 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53713 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53714 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53719 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53721 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53722 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53723 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53724 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53725 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53730 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53731 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53740 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53741 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53742 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53743 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53746 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53748 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53749 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53750 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53751 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53753 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53758 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53759 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53760 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53761 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53762 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53763 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53764 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53765 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53766 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53767 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53768 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53770 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53771 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53772 { NULL, NULL, 0, NULL }
53773 };
53774
53775
53776 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53777
53778 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53779 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53780 }
53781 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53782 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53783 }
53784 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53785 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53786 }
53787 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53788 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53789 }
53790 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53791 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53792 }
53793 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53794 return (void *)((wxSizer *) ((wxGridSizer *) x));
53795 }
53796 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53797 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53798 }
53799 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53800 return (void *)((wxSizer *) ((wxPySizer *) x));
53801 }
53802 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53803 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53804 }
53805 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53806 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53807 }
53808 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53809 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53810 }
53811 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53812 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53813 }
53814 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53815 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53816 }
53817 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53818 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53819 }
53820 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53821 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53822 }
53823 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53824 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53825 }
53826 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53827 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53828 }
53829 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53830 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53831 }
53832 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53833 return (void *)((wxEvent *) ((wxPyEvent *) x));
53834 }
53835 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53836 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53837 }
53838 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53839 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53840 }
53841 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53842 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53843 }
53844 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53845 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53846 }
53847 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53848 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53849 }
53850 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53851 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53852 }
53853 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53854 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53855 }
53856 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53857 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53858 }
53859 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53860 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53861 }
53862 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53864 }
53865 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53866 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53867 }
53868 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53869 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53870 }
53871 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53872 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53873 }
53874 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53875 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53876 }
53877 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53878 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53879 }
53880 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53881 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53882 }
53883 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53884 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53885 }
53886 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53887 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53888 }
53889 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53890 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53891 }
53892 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53893 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53894 }
53895 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53896 return (void *)((wxEvent *) ((wxShowEvent *) x));
53897 }
53898 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53899 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53900 }
53901 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53902 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53903 }
53904 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53906 }
53907 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53909 }
53910 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53912 }
53913 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53915 }
53916 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53917 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53918 }
53919 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53920 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53921 }
53922 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53923 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53924 }
53925 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53926 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53927 }
53928 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53929 return (void *)((wxControl *) ((wxControlWithItems *) x));
53930 }
53931 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53932 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53933 }
53934 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53935 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53936 }
53937 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53938 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53939 }
53940 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53941 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53942 }
53943 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53944 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53945 }
53946 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53947 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53948 }
53949 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53950 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53951 }
53952 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53953 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53954 }
53955 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53956 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53957 }
53958 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53959 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53960 }
53961 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53962 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53963 }
53964 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53965 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53966 }
53967 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53968 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53969 }
53970 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53971 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53972 }
53973 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
53974 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
53975 }
53976 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
53977 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
53978 }
53979 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
53980 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
53981 }
53982 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
53983 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
53984 }
53985 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
53986 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53987 }
53988 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
53989 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
53990 }
53991 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
53992 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
53993 }
53994 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
53995 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
53996 }
53997 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
53998 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
53999 }
54000 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54001 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54002 }
54003 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54004 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54005 }
54006 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54007 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54008 }
54009 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54010 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54011 }
54012 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54013 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54014 }
54015 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54016 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54017 }
54018 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54019 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54020 }
54021 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54022 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54023 }
54024 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54025 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54026 }
54027 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54028 return (void *)((wxObject *) ((wxSizerItem *) x));
54029 }
54030 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54031 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54032 }
54033 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54034 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54035 }
54036 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54037 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54038 }
54039 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54040 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54041 }
54042 static void *_p_wxSizerTo_p_wxObject(void *x) {
54043 return (void *)((wxObject *) ((wxSizer *) x));
54044 }
54045 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54046 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54047 }
54048 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54050 }
54051 static void *_p_wxEventTo_p_wxObject(void *x) {
54052 return (void *)((wxObject *) ((wxEvent *) x));
54053 }
54054 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54055 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54056 }
54057 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54058 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54059 }
54060 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54061 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54062 }
54063 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54064 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54065 }
54066 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54067 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54068 }
54069 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54070 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54071 }
54072 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54073 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54074 }
54075 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54076 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54077 }
54078 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54079 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54080 }
54081 static void *_p_wxControlTo_p_wxObject(void *x) {
54082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54083 }
54084 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54085 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54086 }
54087 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54088 return (void *)((wxObject *) ((wxFSFile *) x));
54089 }
54090 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54091 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54092 }
54093 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54094 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54095 }
54096 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54097 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54098 }
54099 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54100 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54101 }
54102 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54103 return (void *)((wxObject *) ((wxMenuItem *) x));
54104 }
54105 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54106 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54107 }
54108 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54109 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54110 }
54111 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54112 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54113 }
54114 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54115 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54116 }
54117 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54119 }
54120 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54122 }
54123 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54125 }
54126 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54128 }
54129 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54131 }
54132 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54134 }
54135 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54137 }
54138 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54140 }
54141 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54143 }
54144 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54146 }
54147 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54149 }
54150 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54152 }
54153 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54155 }
54156 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54158 }
54159 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54161 }
54162 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) ((wxImageHandler *) x));
54164 }
54165 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54167 }
54168 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54170 }
54171 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) ((wxEvtHandler *) x));
54173 }
54174 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54176 }
54177 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54179 }
54180 static void *_p_wxImageTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) ((wxImage *) x));
54182 }
54183 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54185 }
54186 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54188 }
54189 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54191 }
54192 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54194 }
54195 static void *_p_wxWindowTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54197 }
54198 static void *_p_wxMenuTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54200 }
54201 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54203 }
54204 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) ((wxFileSystem *) x));
54206 }
54207 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54209 }
54210 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54212 }
54213 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54215 }
54216 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54218 }
54219 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54221 }
54222 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54224 }
54225 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54227 }
54228 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54230 }
54231 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54233 }
54234 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54236 }
54237 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54239 }
54240 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54242 }
54243 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54245 }
54246 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54248 }
54249 static void *_p_wxControlTo_p_wxWindow(void *x) {
54250 return (void *)((wxWindow *) ((wxControl *) x));
54251 }
54252 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54253 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54254 }
54255 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54256 return (void *)((wxWindow *) ((wxMenuBar *) x));
54257 }
54258 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54259 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54260 }
54261 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54262 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54263 }
54264 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54265 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54266 }
54267 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54268 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54269 }
54270 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54271 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54272 }
54273 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54274 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54275 }
54276 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54277 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54278 }
54279 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54280 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54281 }
54282 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54283 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54284 }
54285 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54286 return (void *)((wxValidator *) ((wxPyValidator *) x));
54287 }
54288 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54289 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54290 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};
54291 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54292 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54293 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54294 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54295 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54296 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54297 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54298 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54299 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54300 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54301 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54302 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54303 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54304 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54305 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54306 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54307 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54308 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54309 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54310 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54311 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54312 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54313 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54314 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54315 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54316 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54317 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54318 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54319 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54320 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54338 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54339 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54340 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54341 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54342 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54344 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54345 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54417
54418 static swig_type_info *swig_type_initial[] = {
54419 &_swigt__p_buffer,
54420 &_swigt__p_char,
54421 &_swigt__p_form_ops_t,
54422 &_swigt__p_int,
54423 &_swigt__p_long,
54424 &_swigt__p_unsigned_char,
54425 &_swigt__p_unsigned_int,
54426 &_swigt__p_unsigned_long,
54427 &_swigt__p_wxANIHandler,
54428 &_swigt__p_wxAcceleratorEntry,
54429 &_swigt__p_wxAcceleratorTable,
54430 &_swigt__p_wxActivateEvent,
54431 &_swigt__p_wxAppTraits,
54432 &_swigt__p_wxArrayString,
54433 &_swigt__p_wxBMPHandler,
54434 &_swigt__p_wxBitmap,
54435 &_swigt__p_wxBoxSizer,
54436 &_swigt__p_wxButton,
54437 &_swigt__p_wxCURHandler,
54438 &_swigt__p_wxCaret,
54439 &_swigt__p_wxChildFocusEvent,
54440 &_swigt__p_wxCloseEvent,
54441 &_swigt__p_wxColour,
54442 &_swigt__p_wxCommandEvent,
54443 &_swigt__p_wxContextMenuEvent,
54444 &_swigt__p_wxControl,
54445 &_swigt__p_wxControlWithItems,
54446 &_swigt__p_wxCursor,
54447 &_swigt__p_wxDC,
54448 &_swigt__p_wxDateEvent,
54449 &_swigt__p_wxDateTime,
54450 &_swigt__p_wxDisplayChangedEvent,
54451 &_swigt__p_wxDropFilesEvent,
54452 &_swigt__p_wxDuplexMode,
54453 &_swigt__p_wxEraseEvent,
54454 &_swigt__p_wxEvent,
54455 &_swigt__p_wxEventLoop,
54456 &_swigt__p_wxEventLoopActivator,
54457 &_swigt__p_wxEvtHandler,
54458 &_swigt__p_wxFSFile,
54459 &_swigt__p_wxFileSystem,
54460 &_swigt__p_wxFileSystemHandler,
54461 &_swigt__p_wxFlexGridSizer,
54462 &_swigt__p_wxFocusEvent,
54463 &_swigt__p_wxFont,
54464 &_swigt__p_wxFrame,
54465 &_swigt__p_wxGBPosition,
54466 &_swigt__p_wxGBSizerItem,
54467 &_swigt__p_wxGBSpan,
54468 &_swigt__p_wxGIFHandler,
54469 &_swigt__p_wxGridBagSizer,
54470 &_swigt__p_wxGridSizer,
54471 &_swigt__p_wxICOHandler,
54472 &_swigt__p_wxIconizeEvent,
54473 &_swigt__p_wxIdleEvent,
54474 &_swigt__p_wxImage,
54475 &_swigt__p_wxImageHandler,
54476 &_swigt__p_wxImageHistogram,
54477 &_swigt__p_wxImage_HSVValue,
54478 &_swigt__p_wxImage_RGBValue,
54479 &_swigt__p_wxIndividualLayoutConstraint,
54480 &_swigt__p_wxInitDialogEvent,
54481 &_swigt__p_wxInputStream,
54482 &_swigt__p_wxInternetFSHandler,
54483 &_swigt__p_wxItemContainer,
54484 &_swigt__p_wxJPEGHandler,
54485 &_swigt__p_wxKeyEvent,
54486 &_swigt__p_wxLayoutConstraints,
54487 &_swigt__p_wxMaximizeEvent,
54488 &_swigt__p_wxMemoryFSHandler,
54489 &_swigt__p_wxMenu,
54490 &_swigt__p_wxMenuBar,
54491 &_swigt__p_wxMenuBarBase,
54492 &_swigt__p_wxMenuEvent,
54493 &_swigt__p_wxMenuItem,
54494 &_swigt__p_wxMouseCaptureChangedEvent,
54495 &_swigt__p_wxMouseEvent,
54496 &_swigt__p_wxMoveEvent,
54497 &_swigt__p_wxNavigationKeyEvent,
54498 &_swigt__p_wxNcPaintEvent,
54499 &_swigt__p_wxNotifyEvent,
54500 &_swigt__p_wxObject,
54501 &_swigt__p_wxOutputStream,
54502 &_swigt__p_wxPCXHandler,
54503 &_swigt__p_wxPNGHandler,
54504 &_swigt__p_wxPNMHandler,
54505 &_swigt__p_wxPaintEvent,
54506 &_swigt__p_wxPaletteChangedEvent,
54507 &_swigt__p_wxPaperSize,
54508 &_swigt__p_wxPoint,
54509 &_swigt__p_wxPoint2D,
54510 &_swigt__p_wxPropagateOnce,
54511 &_swigt__p_wxPropagationDisabler,
54512 &_swigt__p_wxPyApp,
54513 &_swigt__p_wxPyCommandEvent,
54514 &_swigt__p_wxPyDropTarget,
54515 &_swigt__p_wxPyEvent,
54516 &_swigt__p_wxPyFileSystemHandler,
54517 &_swigt__p_wxPyImageHandler,
54518 &_swigt__p_wxPyInputStream,
54519 &_swigt__p_wxPySizer,
54520 &_swigt__p_wxPyValidator,
54521 &_swigt__p_wxQuantize,
54522 &_swigt__p_wxQueryNewPaletteEvent,
54523 &_swigt__p_wxRealPoint,
54524 &_swigt__p_wxRect,
54525 &_swigt__p_wxRegion,
54526 &_swigt__p_wxScrollEvent,
54527 &_swigt__p_wxScrollWinEvent,
54528 &_swigt__p_wxSetCursorEvent,
54529 &_swigt__p_wxShowEvent,
54530 &_swigt__p_wxSize,
54531 &_swigt__p_wxSizeEvent,
54532 &_swigt__p_wxSizer,
54533 &_swigt__p_wxSizerItem,
54534 &_swigt__p_wxStaticBox,
54535 &_swigt__p_wxStaticBoxSizer,
54536 &_swigt__p_wxStdDialogButtonSizer,
54537 &_swigt__p_wxSysColourChangedEvent,
54538 &_swigt__p_wxTIFFHandler,
54539 &_swigt__p_wxToolTip,
54540 &_swigt__p_wxUpdateUIEvent,
54541 &_swigt__p_wxValidator,
54542 &_swigt__p_wxVisualAttributes,
54543 &_swigt__p_wxWindow,
54544 &_swigt__p_wxWindowCreateEvent,
54545 &_swigt__p_wxWindowDestroyEvent,
54546 &_swigt__p_wxXPMHandler,
54547 &_swigt__p_wxZipFSHandler,
54548 };
54549
54550 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54551 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54552 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54553 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54554 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54555 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54556 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54557 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54558 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54559 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54560 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54561 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54562 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54563 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54564 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}};
54565 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54566 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}};
54567 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54568 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}};
54569 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54570 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54571 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54572 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54573 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54574 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54575 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}};
54576 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54577 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54578 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54579 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54584 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54585 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54586 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54588 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}};
54589 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54590 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54591 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}};
54592 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}};
54593 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54594 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54595 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54596 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54597 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54598 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54600 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54601 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}};
54602 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}};
54603 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54604 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54605 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54606 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}};
54607 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54608 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54609 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54612 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54613 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54614 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}};
54615 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54616 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54617 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54618 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54619 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54620 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54621 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54628 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54629 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54630 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54635 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54636 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54642 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54644 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54645 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54660 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54663 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}};
54664 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}};
54665 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54672 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}};
54673 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54674 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}};
54675 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54679
54680 static swig_cast_info *swig_cast_initial[] = {
54681 _swigc__p_buffer,
54682 _swigc__p_char,
54683 _swigc__p_form_ops_t,
54684 _swigc__p_int,
54685 _swigc__p_long,
54686 _swigc__p_unsigned_char,
54687 _swigc__p_unsigned_int,
54688 _swigc__p_unsigned_long,
54689 _swigc__p_wxANIHandler,
54690 _swigc__p_wxAcceleratorEntry,
54691 _swigc__p_wxAcceleratorTable,
54692 _swigc__p_wxActivateEvent,
54693 _swigc__p_wxAppTraits,
54694 _swigc__p_wxArrayString,
54695 _swigc__p_wxBMPHandler,
54696 _swigc__p_wxBitmap,
54697 _swigc__p_wxBoxSizer,
54698 _swigc__p_wxButton,
54699 _swigc__p_wxCURHandler,
54700 _swigc__p_wxCaret,
54701 _swigc__p_wxChildFocusEvent,
54702 _swigc__p_wxCloseEvent,
54703 _swigc__p_wxColour,
54704 _swigc__p_wxCommandEvent,
54705 _swigc__p_wxContextMenuEvent,
54706 _swigc__p_wxControl,
54707 _swigc__p_wxControlWithItems,
54708 _swigc__p_wxCursor,
54709 _swigc__p_wxDC,
54710 _swigc__p_wxDateEvent,
54711 _swigc__p_wxDateTime,
54712 _swigc__p_wxDisplayChangedEvent,
54713 _swigc__p_wxDropFilesEvent,
54714 _swigc__p_wxDuplexMode,
54715 _swigc__p_wxEraseEvent,
54716 _swigc__p_wxEvent,
54717 _swigc__p_wxEventLoop,
54718 _swigc__p_wxEventLoopActivator,
54719 _swigc__p_wxEvtHandler,
54720 _swigc__p_wxFSFile,
54721 _swigc__p_wxFileSystem,
54722 _swigc__p_wxFileSystemHandler,
54723 _swigc__p_wxFlexGridSizer,
54724 _swigc__p_wxFocusEvent,
54725 _swigc__p_wxFont,
54726 _swigc__p_wxFrame,
54727 _swigc__p_wxGBPosition,
54728 _swigc__p_wxGBSizerItem,
54729 _swigc__p_wxGBSpan,
54730 _swigc__p_wxGIFHandler,
54731 _swigc__p_wxGridBagSizer,
54732 _swigc__p_wxGridSizer,
54733 _swigc__p_wxICOHandler,
54734 _swigc__p_wxIconizeEvent,
54735 _swigc__p_wxIdleEvent,
54736 _swigc__p_wxImage,
54737 _swigc__p_wxImageHandler,
54738 _swigc__p_wxImageHistogram,
54739 _swigc__p_wxImage_HSVValue,
54740 _swigc__p_wxImage_RGBValue,
54741 _swigc__p_wxIndividualLayoutConstraint,
54742 _swigc__p_wxInitDialogEvent,
54743 _swigc__p_wxInputStream,
54744 _swigc__p_wxInternetFSHandler,
54745 _swigc__p_wxItemContainer,
54746 _swigc__p_wxJPEGHandler,
54747 _swigc__p_wxKeyEvent,
54748 _swigc__p_wxLayoutConstraints,
54749 _swigc__p_wxMaximizeEvent,
54750 _swigc__p_wxMemoryFSHandler,
54751 _swigc__p_wxMenu,
54752 _swigc__p_wxMenuBar,
54753 _swigc__p_wxMenuBarBase,
54754 _swigc__p_wxMenuEvent,
54755 _swigc__p_wxMenuItem,
54756 _swigc__p_wxMouseCaptureChangedEvent,
54757 _swigc__p_wxMouseEvent,
54758 _swigc__p_wxMoveEvent,
54759 _swigc__p_wxNavigationKeyEvent,
54760 _swigc__p_wxNcPaintEvent,
54761 _swigc__p_wxNotifyEvent,
54762 _swigc__p_wxObject,
54763 _swigc__p_wxOutputStream,
54764 _swigc__p_wxPCXHandler,
54765 _swigc__p_wxPNGHandler,
54766 _swigc__p_wxPNMHandler,
54767 _swigc__p_wxPaintEvent,
54768 _swigc__p_wxPaletteChangedEvent,
54769 _swigc__p_wxPaperSize,
54770 _swigc__p_wxPoint,
54771 _swigc__p_wxPoint2D,
54772 _swigc__p_wxPropagateOnce,
54773 _swigc__p_wxPropagationDisabler,
54774 _swigc__p_wxPyApp,
54775 _swigc__p_wxPyCommandEvent,
54776 _swigc__p_wxPyDropTarget,
54777 _swigc__p_wxPyEvent,
54778 _swigc__p_wxPyFileSystemHandler,
54779 _swigc__p_wxPyImageHandler,
54780 _swigc__p_wxPyInputStream,
54781 _swigc__p_wxPySizer,
54782 _swigc__p_wxPyValidator,
54783 _swigc__p_wxQuantize,
54784 _swigc__p_wxQueryNewPaletteEvent,
54785 _swigc__p_wxRealPoint,
54786 _swigc__p_wxRect,
54787 _swigc__p_wxRegion,
54788 _swigc__p_wxScrollEvent,
54789 _swigc__p_wxScrollWinEvent,
54790 _swigc__p_wxSetCursorEvent,
54791 _swigc__p_wxShowEvent,
54792 _swigc__p_wxSize,
54793 _swigc__p_wxSizeEvent,
54794 _swigc__p_wxSizer,
54795 _swigc__p_wxSizerItem,
54796 _swigc__p_wxStaticBox,
54797 _swigc__p_wxStaticBoxSizer,
54798 _swigc__p_wxStdDialogButtonSizer,
54799 _swigc__p_wxSysColourChangedEvent,
54800 _swigc__p_wxTIFFHandler,
54801 _swigc__p_wxToolTip,
54802 _swigc__p_wxUpdateUIEvent,
54803 _swigc__p_wxValidator,
54804 _swigc__p_wxVisualAttributes,
54805 _swigc__p_wxWindow,
54806 _swigc__p_wxWindowCreateEvent,
54807 _swigc__p_wxWindowDestroyEvent,
54808 _swigc__p_wxXPMHandler,
54809 _swigc__p_wxZipFSHandler,
54810 };
54811
54812
54813 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54814
54815 static swig_const_info swig_const_table[] = {
54816 {0, 0, 0, 0.0, 0, 0}};
54817
54818 #ifdef __cplusplus
54819 }
54820 #endif
54821 /* -----------------------------------------------------------------------------
54822 * Type initialization:
54823 * This problem is tough by the requirement that no dynamic
54824 * memory is used. Also, since swig_type_info structures store pointers to
54825 * swig_cast_info structures and swig_cast_info structures store pointers back
54826 * to swig_type_info structures, we need some lookup code at initialization.
54827 * The idea is that swig generates all the structures that are needed.
54828 * The runtime then collects these partially filled structures.
54829 * The SWIG_InitializeModule function takes these initial arrays out of
54830 * swig_module, and does all the lookup, filling in the swig_module.types
54831 * array with the correct data and linking the correct swig_cast_info
54832 * structures together.
54833 *
54834 * The generated swig_type_info structures are assigned staticly to an initial
54835 * array. We just loop though that array, and handle each type individually.
54836 * First we lookup if this type has been already loaded, and if so, use the
54837 * loaded structure instead of the generated one. Then we have to fill in the
54838 * cast linked list. The cast data is initially stored in something like a
54839 * two-dimensional array. Each row corresponds to a type (there are the same
54840 * number of rows as there are in the swig_type_initial array). Each entry in
54841 * a column is one of the swig_cast_info structures for that type.
54842 * The cast_initial array is actually an array of arrays, because each row has
54843 * a variable number of columns. So to actually build the cast linked list,
54844 * we find the array of casts associated with the type, and loop through it
54845 * adding the casts to the list. The one last trick we need to do is making
54846 * sure the type pointer in the swig_cast_info struct is correct.
54847 *
54848 * First off, we lookup the cast->type name to see if it is already loaded.
54849 * There are three cases to handle:
54850 * 1) If the cast->type has already been loaded AND the type we are adding
54851 * casting info to has not been loaded (it is in this module), THEN we
54852 * replace the cast->type pointer with the type pointer that has already
54853 * been loaded.
54854 * 2) If BOTH types (the one we are adding casting info to, and the
54855 * cast->type) are loaded, THEN the cast info has already been loaded by
54856 * the previous module so we just ignore it.
54857 * 3) Finally, if cast->type has not already been loaded, then we add that
54858 * swig_cast_info to the linked list (because the cast->type) pointer will
54859 * be correct.
54860 * ----------------------------------------------------------------------------- */
54861
54862 #ifdef __cplusplus
54863 extern "C" {
54864 #if 0
54865 } /* c-mode */
54866 #endif
54867 #endif
54868
54869 #if 0
54870 #define SWIGRUNTIME_DEBUG
54871 #endif
54872
54873 SWIGRUNTIME void
54874 SWIG_InitializeModule(void *clientdata) {
54875 size_t i;
54876 swig_module_info *module_head;
54877 static int init_run = 0;
54878
54879 clientdata = clientdata;
54880
54881 if (init_run) return;
54882 init_run = 1;
54883
54884 /* Initialize the swig_module */
54885 swig_module.type_initial = swig_type_initial;
54886 swig_module.cast_initial = swig_cast_initial;
54887
54888 /* Try and load any already created modules */
54889 module_head = SWIG_GetModule(clientdata);
54890 if (module_head) {
54891 swig_module.next = module_head->next;
54892 module_head->next = &swig_module;
54893 } else {
54894 /* This is the first module loaded */
54895 swig_module.next = &swig_module;
54896 SWIG_SetModule(clientdata, &swig_module);
54897 }
54898
54899 /* Now work on filling in swig_module.types */
54900 #ifdef SWIGRUNTIME_DEBUG
54901 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54902 #endif
54903 for (i = 0; i < swig_module.size; ++i) {
54904 swig_type_info *type = 0;
54905 swig_type_info *ret;
54906 swig_cast_info *cast;
54907
54908 #ifdef SWIGRUNTIME_DEBUG
54909 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54910 #endif
54911
54912 /* if there is another module already loaded */
54913 if (swig_module.next != &swig_module) {
54914 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54915 }
54916 if (type) {
54917 /* Overwrite clientdata field */
54918 #ifdef SWIGRUNTIME_DEBUG
54919 printf("SWIG_InitializeModule: found type %s\n", type->name);
54920 #endif
54921 if (swig_module.type_initial[i]->clientdata) {
54922 type->clientdata = swig_module.type_initial[i]->clientdata;
54923 #ifdef SWIGRUNTIME_DEBUG
54924 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54925 #endif
54926 }
54927 } else {
54928 type = swig_module.type_initial[i];
54929 }
54930
54931 /* Insert casting types */
54932 cast = swig_module.cast_initial[i];
54933 while (cast->type) {
54934 /* Don't need to add information already in the list */
54935 ret = 0;
54936 #ifdef SWIGRUNTIME_DEBUG
54937 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54938 #endif
54939 if (swig_module.next != &swig_module) {
54940 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54941 #ifdef SWIGRUNTIME_DEBUG
54942 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54943 #endif
54944 }
54945 if (ret) {
54946 if (type == swig_module.type_initial[i]) {
54947 #ifdef SWIGRUNTIME_DEBUG
54948 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54949 #endif
54950 cast->type = ret;
54951 ret = 0;
54952 } else {
54953 /* Check for casting already in the list */
54954 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54955 #ifdef SWIGRUNTIME_DEBUG
54956 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54957 #endif
54958 if (!ocast) ret = 0;
54959 }
54960 }
54961
54962 if (!ret) {
54963 #ifdef SWIGRUNTIME_DEBUG
54964 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54965 #endif
54966 if (type->cast) {
54967 type->cast->prev = cast;
54968 cast->next = type->cast;
54969 }
54970 type->cast = cast;
54971 }
54972 cast++;
54973 }
54974 /* Set entry in modules->types array equal to the type */
54975 swig_module.types[i] = type;
54976 }
54977 swig_module.types[i] = 0;
54978
54979 #ifdef SWIGRUNTIME_DEBUG
54980 printf("**** SWIG_InitializeModule: Cast List ******\n");
54981 for (i = 0; i < swig_module.size; ++i) {
54982 int j = 0;
54983 swig_cast_info *cast = swig_module.cast_initial[i];
54984 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54985 while (cast->type) {
54986 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
54987 cast++;
54988 ++j;
54989 }
54990 printf("---- Total casts: %d\n",j);
54991 }
54992 printf("**** SWIG_InitializeModule: Cast List ******\n");
54993 #endif
54994 }
54995
54996 /* This function will propagate the clientdata field of type to
54997 * any new swig_type_info structures that have been added into the list
54998 * of equivalent types. It is like calling
54999 * SWIG_TypeClientData(type, clientdata) a second time.
55000 */
55001 SWIGRUNTIME void
55002 SWIG_PropagateClientData(void) {
55003 size_t i;
55004 swig_cast_info *equiv;
55005 static int init_run = 0;
55006
55007 if (init_run) return;
55008 init_run = 1;
55009
55010 for (i = 0; i < swig_module.size; i++) {
55011 if (swig_module.types[i]->clientdata) {
55012 equiv = swig_module.types[i]->cast;
55013 while (equiv) {
55014 if (!equiv->converter) {
55015 if (equiv->type && !equiv->type->clientdata)
55016 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55017 }
55018 equiv = equiv->next;
55019 }
55020 }
55021 }
55022 }
55023
55024 #ifdef __cplusplus
55025 #if 0
55026 {
55027 /* c-mode */
55028 #endif
55029 }
55030 #endif
55031
55032
55033
55034 #ifdef __cplusplus
55035 extern "C" {
55036 #endif
55037
55038 /* Python-specific SWIG API */
55039 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55040 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55041 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55042
55043 /* -----------------------------------------------------------------------------
55044 * global variable support code.
55045 * ----------------------------------------------------------------------------- */
55046
55047 typedef struct swig_globalvar {
55048 char *name; /* Name of global variable */
55049 PyObject *(*get_attr)(void); /* Return the current value */
55050 int (*set_attr)(PyObject *); /* Set the value */
55051 struct swig_globalvar *next;
55052 } swig_globalvar;
55053
55054 typedef struct swig_varlinkobject {
55055 PyObject_HEAD
55056 swig_globalvar *vars;
55057 } swig_varlinkobject;
55058
55059 SWIGINTERN PyObject *
55060 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55061 return PyString_FromString("<Swig global variables>");
55062 }
55063
55064 SWIGINTERN PyObject *
55065 swig_varlink_str(swig_varlinkobject *v) {
55066 PyObject *str = PyString_FromString("(");
55067 swig_globalvar *var;
55068 for (var = v->vars; var; var=var->next) {
55069 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55070 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55071 }
55072 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55073 return str;
55074 }
55075
55076 SWIGINTERN int
55077 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55078 PyObject *str = swig_varlink_str(v);
55079 fprintf(fp,"Swig global variables ");
55080 fprintf(fp,"%s\n", PyString_AsString(str));
55081 Py_DECREF(str);
55082 return 0;
55083 }
55084
55085 SWIGINTERN void
55086 swig_varlink_dealloc(swig_varlinkobject *v) {
55087 swig_globalvar *var = v->vars;
55088 while (var) {
55089 swig_globalvar *n = var->next;
55090 free(var->name);
55091 free(var);
55092 var = n;
55093 }
55094 }
55095
55096 SWIGINTERN PyObject *
55097 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55098 PyObject *res = NULL;
55099 swig_globalvar *var = v->vars;
55100 while (var) {
55101 if (strcmp(var->name,n) == 0) {
55102 res = (*var->get_attr)();
55103 break;
55104 }
55105 var = var->next;
55106 }
55107 if (res == NULL && !PyErr_Occurred()) {
55108 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55109 }
55110 return res;
55111 }
55112
55113 SWIGINTERN int
55114 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55115 int res = 1;
55116 swig_globalvar *var = v->vars;
55117 while (var) {
55118 if (strcmp(var->name,n) == 0) {
55119 res = (*var->set_attr)(p);
55120 break;
55121 }
55122 var = var->next;
55123 }
55124 if (res == 1 && !PyErr_Occurred()) {
55125 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55126 }
55127 return res;
55128 }
55129
55130 SWIGINTERN PyTypeObject*
55131 swig_varlink_type(void) {
55132 static char varlink__doc__[] = "Swig var link object";
55133 static PyTypeObject varlink_type;
55134 static int type_init = 0;
55135 if (!type_init) {
55136 const PyTypeObject tmp
55137 = {
55138 PyObject_HEAD_INIT(NULL)
55139 0, /* Number of items in variable part (ob_size) */
55140 (char *)"swigvarlink", /* Type name (tp_name) */
55141 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55142 0, /* Itemsize (tp_itemsize) */
55143 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55144 (printfunc) swig_varlink_print, /* Print (tp_print) */
55145 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55146 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55147 0, /* tp_compare */
55148 (reprfunc) swig_varlink_repr, /* tp_repr */
55149 0, /* tp_as_number */
55150 0, /* tp_as_sequence */
55151 0, /* tp_as_mapping */
55152 0, /* tp_hash */
55153 0, /* tp_call */
55154 (reprfunc)swig_varlink_str, /* tp_str */
55155 0, /* tp_getattro */
55156 0, /* tp_setattro */
55157 0, /* tp_as_buffer */
55158 0, /* tp_flags */
55159 varlink__doc__, /* tp_doc */
55160 0, /* tp_traverse */
55161 0, /* tp_clear */
55162 0, /* tp_richcompare */
55163 0, /* tp_weaklistoffset */
55164 #if PY_VERSION_HEX >= 0x02020000
55165 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55166 #endif
55167 #if PY_VERSION_HEX >= 0x02030000
55168 0, /* tp_del */
55169 #endif
55170 #ifdef COUNT_ALLOCS
55171 0,0,0,0 /* tp_alloc -> tp_next */
55172 #endif
55173 };
55174 varlink_type = tmp;
55175 varlink_type.ob_type = &PyType_Type;
55176 type_init = 1;
55177 }
55178 return &varlink_type;
55179 }
55180
55181 /* Create a variable linking object for use later */
55182 SWIGINTERN PyObject *
55183 SWIG_Python_newvarlink(void) {
55184 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55185 if (result) {
55186 result->vars = 0;
55187 }
55188 return ((PyObject*) result);
55189 }
55190
55191 SWIGINTERN void
55192 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55193 swig_varlinkobject *v = (swig_varlinkobject *) p;
55194 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55195 if (gv) {
55196 size_t size = strlen(name)+1;
55197 gv->name = (char *)malloc(size);
55198 if (gv->name) {
55199 strncpy(gv->name,name,size);
55200 gv->get_attr = get_attr;
55201 gv->set_attr = set_attr;
55202 gv->next = v->vars;
55203 }
55204 }
55205 v->vars = gv;
55206 }
55207
55208 SWIGINTERN PyObject *
55209 SWIG_globals() {
55210 static PyObject *_SWIG_globals = 0;
55211 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55212 return _SWIG_globals;
55213 }
55214
55215 /* -----------------------------------------------------------------------------
55216 * constants/methods manipulation
55217 * ----------------------------------------------------------------------------- */
55218
55219 /* Install Constants */
55220 SWIGINTERN void
55221 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55222 PyObject *obj = 0;
55223 size_t i;
55224 for (i = 0; constants[i].type; ++i) {
55225 switch(constants[i].type) {
55226 case SWIG_PY_POINTER:
55227 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55228 break;
55229 case SWIG_PY_BINARY:
55230 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55231 break;
55232 default:
55233 obj = 0;
55234 break;
55235 }
55236 if (obj) {
55237 PyDict_SetItemString(d, constants[i].name, obj);
55238 Py_DECREF(obj);
55239 }
55240 }
55241 }
55242
55243 /* -----------------------------------------------------------------------------*/
55244 /* Fix SwigMethods to carry the callback ptrs when needed */
55245 /* -----------------------------------------------------------------------------*/
55246
55247 SWIGINTERN void
55248 SWIG_Python_FixMethods(PyMethodDef *methods,
55249 swig_const_info *const_table,
55250 swig_type_info **types,
55251 swig_type_info **types_initial) {
55252 size_t i;
55253 for (i = 0; methods[i].ml_name; ++i) {
55254 char *c = methods[i].ml_doc;
55255 if (c && (c = strstr(c, "swig_ptr: "))) {
55256 int j;
55257 swig_const_info *ci = 0;
55258 char *name = c + 10;
55259 for (j = 0; const_table[j].type; ++j) {
55260 if (strncmp(const_table[j].name, name,
55261 strlen(const_table[j].name)) == 0) {
55262 ci = &(const_table[j]);
55263 break;
55264 }
55265 }
55266 if (ci) {
55267 size_t shift = (ci->ptype) - types;
55268 swig_type_info *ty = types_initial[shift];
55269 size_t ldoc = (c - methods[i].ml_doc);
55270 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55271 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55272 if (ndoc) {
55273 char *buff = ndoc;
55274 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55275 if (ptr) {
55276 strncpy(buff, methods[i].ml_doc, ldoc);
55277 buff += ldoc;
55278 strncpy(buff, "swig_ptr: ", 10);
55279 buff += 10;
55280 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55281 methods[i].ml_doc = ndoc;
55282 }
55283 }
55284 }
55285 }
55286 }
55287 }
55288
55289 #ifdef __cplusplus
55290 }
55291 #endif
55292
55293 /* -----------------------------------------------------------------------------*
55294 * Partial Init method
55295 * -----------------------------------------------------------------------------*/
55296
55297 #ifdef __cplusplus
55298 extern "C"
55299 #endif
55300 SWIGEXPORT void SWIG_init(void) {
55301 PyObject *m, *d;
55302
55303 /* Fix SwigMethods to carry the callback ptrs when needed */
55304 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55305
55306 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55307 d = PyModule_GetDict(m);
55308
55309 SWIG_InitializeModule(0);
55310 SWIG_InstallConstants(d,swig_const_table);
55311
55312
55313
55314 #ifndef wxPyUSE_EXPORT
55315 // Make our API structure a CObject so other modules can import it
55316 // from this module.
55317 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55318 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55319 Py_XDECREF(cobj);
55320 #endif
55321
55322 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55323 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55324 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55325 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55326 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55327 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55328 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55329 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55330 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55331 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55332 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55333 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55334 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55335 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55336 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55337 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55338 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55339 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55340 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55341 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55342 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55343 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55344 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55345 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55346 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55347 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55348 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55349 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55350 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55351 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55352 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55353 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55354 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55355 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55356 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55357 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55358 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55359 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55360 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55361 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55362 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55363 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55364 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55365 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55366 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55367 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55368 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55369 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55370 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55371 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55372 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55373 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55374 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55375 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55376 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55377 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55378 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55379 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55380 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55381 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55382 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55383 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55384 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55385 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55386 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55387 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55388 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55389 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55390 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55391 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55392 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55393 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55394 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55395 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55396 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55397 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55398 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55399 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55400 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55401 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55402 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55403 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55404 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55405 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55406 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55407 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55408 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55409 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55410 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55411 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55412 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55413 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55414 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55415 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55416 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55417 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55418 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55419 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55420 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55421 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55422 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55423 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55424 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55425 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55426 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55427 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55428 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55429 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55430 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55431 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55432 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55433 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55434 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55435 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55436 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55437 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55438 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55439 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55440 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55441 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55442 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55443 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55444 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55445 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55446 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55447 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55448 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55449 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55450 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55451 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55452 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55453 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55454 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55455 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55456 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55457 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55458 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55459 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55460 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55461 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55462 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55463 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55464 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55465 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55466 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55467 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55468 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55469 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55470 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55471 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55472 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55473 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55474 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55475 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55476 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55477 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55478 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55479 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55480 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55481 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55482 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55483 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55484 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55485 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55486 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55487 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55488 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55489 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55490 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55491 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55492 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55493 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55494 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55495 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55496 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55497 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55498 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55499 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55500 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55501 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55502 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55503 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55504 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55505 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55506 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55507 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55508 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55509 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55510 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55511 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55512 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55513 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55514 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55515 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55516 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55517 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55518 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55519 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55520 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55521 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55522 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55523 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55524 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55525 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55526 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55527 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55528 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55529 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55530 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55531 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55532 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55533 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55534 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55535 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55536 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55537 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55538 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55539 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55540 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55541 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55542 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55543 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55544 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55545 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55546 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55547 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55548 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55549 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55550 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55551 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55552 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55553 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55554 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55555 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55556 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55557 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55558 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55559 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55560 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55561 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55562 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55563 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55564 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55565 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55566 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55567 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55568 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55569 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55570 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55571 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55572 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55573 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55574 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55575 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55576 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55577 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55578 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55579 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55580 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55581 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55582 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55583 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55584 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55585 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55586 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55587 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55588 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55589 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55590 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55591 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55592 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55593 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55594 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55595 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55596 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55597 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55598 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55599 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55600 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55601 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55602 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55603 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55604 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55605 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55606 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55607 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55608 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55609 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55610 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55611 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55612 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55613 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55614 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55615 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55616 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55617 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55618 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55619 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55620 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55621 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55622 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55623 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55624 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55625 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55626 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55627 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55628 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55629 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55630 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55631 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55632 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55633 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55634 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55635 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55636 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55637 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55638 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55639 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55640 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55641 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55642 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55643 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55644 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55645 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55646 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55647 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55648 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55649 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55650 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55651 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55652 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55653 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55654 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55655 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55656 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55657 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55658 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55659 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55660 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55661 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55662 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55663 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55664 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55665 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55666 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55667 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55668 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55669 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55670 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55671 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55672 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55673 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55674 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55675 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55676 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55677 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55678 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55679 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55680 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55681 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55682 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55683 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55684 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55685 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55686 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55687 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55688 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55689 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55690 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55691 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55692 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55693 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55694 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55695 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55696 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55697 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55698 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55699 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55700 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55701 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55702 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55703 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55704 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55705 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55706 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55707 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55708 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55709 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55710 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55711 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55712 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55713 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55714 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55715 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55716 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55717 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55718 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55719 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55720 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55721 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55722 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55723 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55724 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55725 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55726 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55727 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55728 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55729 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55730 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55731 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55732 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55733 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55734 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55735 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55736 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55737 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55738 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55739 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55740 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55741 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55742 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55743 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55744 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55745 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55746 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55747 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55748 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55749 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55750 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55751 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55752 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55753 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55754 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55755 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55756 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55757 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55758 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55759 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55760 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55761 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55762 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55763 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55764 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55765 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55766 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55767 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55768 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55769 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55770 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55771 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55772 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55773 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55774 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55775 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55776 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55777 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55778 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55779 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55780 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55781 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55782 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55783 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55784 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55785 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55786 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55787 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55788 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55789 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55790 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55791 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55792 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55793 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55794 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55795 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55796 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55797 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55798 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55799 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55800 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55801 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55802 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55803 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55804 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55805 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55806 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55807 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55808 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55809 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55810 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55811 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55812 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55813 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55814 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55815 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55816 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55817 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55818 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55819 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55820 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55821 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55822 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55823 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55824 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55825 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55826 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55827 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55828 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55829 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55830 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55831 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55832 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55833 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55834 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55835 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55836 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55837 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55838 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55839 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55840 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55841 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55842 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55843 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55844 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55845 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55846 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55847 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55848 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55849 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55850 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55851 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55852 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55853 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55854 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55855 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55856 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55857 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55858 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55859 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55860 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55861 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55862 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55863 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55864 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55865 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55866 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55867 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55868 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55869 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55870 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55871 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55872 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55873 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55874 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55875 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55876 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55877 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55878 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55879 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55880 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55881 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55882 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55883 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55884 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55885 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55886 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55887 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55888 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55889 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55890 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55891 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55892 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55893 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55894 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55895 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55896 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55897 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55898 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55899 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55900 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55901 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55902 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55903 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55904 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55905 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55906 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55907 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55908 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55909 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55910 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55911 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55912 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55913 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55914 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55915 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55916 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55917 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55918 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55919 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55920 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55921 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55922 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55923 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55924 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55925 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55926 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55927 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55928 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55929 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55930 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55931 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55932 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55933 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55934 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55935 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55936 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55937 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55938 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55939 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55940 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55941 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55942 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55943 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55944 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55945 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55946 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55947 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55948 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55949 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55950 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55951 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55952 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55953 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55954 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55955 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55956 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55957 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55958 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55959 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55960 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55961 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55962 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55963 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55964 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55965 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55966 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55967 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55968 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55969 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55970 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55971 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55972 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
55973 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
55974 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
55975 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
55976 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
55977 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
55978 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
55979 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
55980 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
55981 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
55982 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
55983 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
55984 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
55985 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
55986 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
55987 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
55988 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
55989 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
55990 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
55991
55992 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
55993
55994
55995 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
55996
55997 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
55998 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
55999 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56000 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56001 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56002 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56003 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56004 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56005 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56006 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56007 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56008 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56009 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56010 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56011 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56012 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56013 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56014 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56015 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56016 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56017 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56018 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56019 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56020 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56021 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56022 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56023 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56024 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56025 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56026 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56027 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56028 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56029 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56030 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56031 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56032 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56033 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56034 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56035 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56036 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56037 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56038 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56039 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56040 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56041 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56042 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56043 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56044 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56045 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56046 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56047 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56048 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56049 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56050 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56051 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56052 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56053 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56054 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56055 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56056 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56057 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56058 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56059 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56060 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56061 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56062 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56063 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56064 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56065 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56066 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56067 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56068 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56069 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56070 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56071 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56072 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56073 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56074 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56075 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56076 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56077 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56078 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56079 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56080 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56081 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56082 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56083 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56084 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56085 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56086 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56087 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56088 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56089 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56090 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56091 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56092 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56093 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56094 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56095 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56096 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56097 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56098 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56099 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56100 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56101 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56102 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56103 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56104 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56105 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56106 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56107 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56108 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56109 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56110 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56111 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56112 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56113 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56114 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56115 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56116 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56117 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56118 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56119 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56120 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56121 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56122 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56123 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56124 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56125 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56126 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56127 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56128 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56129 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56130 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56131 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56132 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56133 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56134 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56135 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56136 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56137 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56138 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56139 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56140 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56141 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56142 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56143 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56144 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56145 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56146 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56147 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56148 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56149 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56150 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56151 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56152 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56153 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56154 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56155 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56156 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56157 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56158 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56159 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56160 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56161 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56162 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56163 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56164 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56165 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56166 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56167 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56168 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56169 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56170 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56171 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56172 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56173 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56174 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56175 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56176 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56177 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56178 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56179 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56180 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56181 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56182 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56183 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56184 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56185 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56186 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56187 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56188 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56189 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56190 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56191 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56192 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56193 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56194 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56195 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56196 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56197 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56198 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56199 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56200 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56201
56202 // Initialize threading, some globals and such
56203 __wxPyPreStart(d);
56204
56205
56206 // Although these are defined in __version__ they need to be here too so
56207 // that an assert can be done to ensure that the wxPython and the wxWindows
56208 // versions match.
56209 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56210 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56211 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56212
56213 }
56214
wxWidgets (Impactor)