]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Changes needed for building with Python 2.5
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* 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_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2516 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2522 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2523 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2524 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2525 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2526 #define SWIGTYPE_p_wxInputStream swig_types[64]
2527 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2528 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2529 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2530 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2531 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2532 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2533 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2534 #define SWIGTYPE_p_wxMenu swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2536 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2537 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2544 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxObject swig_types[83]
2546 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2547 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2552 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2553 #define SWIGTYPE_p_wxPoint swig_types[91]
2554 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2555 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2556 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2557 #define SWIGTYPE_p_wxPyApp swig_types[95]
2558 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2560 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2561 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2563 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2564 #define SWIGTYPE_p_wxPySizer swig_types[102]
2565 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2566 #define SWIGTYPE_p_wxQuantize swig_types[104]
2567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2568 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2569 #define SWIGTYPE_p_wxRect swig_types[107]
2570 #define SWIGTYPE_p_wxRegion swig_types[108]
2571 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2572 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2574 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSize swig_types[113]
2576 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2577 #define SWIGTYPE_p_wxSizer swig_types[115]
2578 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2583 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2584 #define SWIGTYPE_p_wxToolTip swig_types[122]
2585 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2586 #define SWIGTYPE_p_wxValidator swig_types[124]
2587 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2588 #define SWIGTYPE_p_wxWindow swig_types[126]
2589 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2590 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2591 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2592 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2593 static swig_type_info *swig_types[132];
2594 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2595 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2596 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2597
2598 /* -------- TYPES TABLE (END) -------- */
2599
2600 #if (PY_VERSION_HEX <= 0x02000000)
2601 # if !defined(SWIG_PYTHON_CLASSIC)
2602 # error "This python version requires to use swig with the '-classic' option"
2603 # endif
2604 #endif
2605 #if (PY_VERSION_HEX <= 0x02020000)
2606 # error "This python version requires to use swig with the '-nomodern' option"
2607 #endif
2608 #if (PY_VERSION_HEX <= 0x02020000)
2609 # error "This python version requires to use swig with the '-nomodernargs' option"
2610 #endif
2611 #ifndef METH_O
2612 # error "This python version requires to use swig with the '-nofastunpack' option"
2613 #endif
2614
2615 /*-----------------------------------------------
2616 @(target):= _core_.so
2617 ------------------------------------------------*/
2618 #define SWIG_init init_core_
2619
2620 #define SWIG_name "_core_"
2621
2622 #define SWIGVERSION 0x010329
2623
2624
2625 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2626 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2627
2628
2629 #include <stdexcept>
2630
2631
2632 namespace swig {
2633 class PyObject_ptr {
2634 protected:
2635 PyObject *_obj;
2636
2637 public:
2638 PyObject_ptr() :_obj(0)
2639 {
2640 }
2641
2642 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2643 {
2644 Py_XINCREF(_obj);
2645 }
2646
2647 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2648 {
2649 if (initial_ref) Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr & operator=(const PyObject_ptr& item)
2653 {
2654 Py_XINCREF(item._obj);
2655 Py_XDECREF(_obj);
2656 _obj = item._obj;
2657 return *this;
2658 }
2659
2660 ~PyObject_ptr()
2661 {
2662 Py_XDECREF(_obj);
2663 }
2664
2665 operator PyObject *() const
2666 {
2667 return _obj;
2668 }
2669
2670 PyObject *operator->() const
2671 {
2672 return _obj;
2673 }
2674 };
2675 }
2676
2677
2678 namespace swig {
2679 struct PyObject_var : PyObject_ptr {
2680 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2681
2682 PyObject_var & operator = (PyObject* obj)
2683 {
2684 Py_XDECREF(_obj);
2685 _obj = obj;
2686 return *this;
2687 }
2688 };
2689 }
2690
2691
2692 #include "wx/wxPython/wxPython_int.h"
2693 #include "wx/wxPython/pyclasses.h"
2694 #include "wx/wxPython/twoitem.h"
2695
2696
2697 #ifndef wxPyUSE_EXPORT
2698 // Helper functions for dealing with SWIG objects and such. These are
2699 // located here so they know about the SWIG types and functions declared
2700 // in the wrapper code.
2701
2702 #include <wx/hashmap.h>
2703 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2704
2705
2706 // Maintains a hashmap of className to swig_type_info pointers. Given the
2707 // name of a class either looks up the type info in the cache, or scans the
2708 // SWIG tables for it.
2709 extern PyObject* wxPyPtrTypeMap;
2710 static
2711 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2712
2713 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2714
2715 if (typeInfoCache == NULL)
2716 typeInfoCache = new wxPyTypeInfoHashMap;
2717
2718 wxString name(className);
2719 swig_type_info* swigType = (*typeInfoCache)[name];
2720
2721 if (! swigType) {
2722 // it wasn't in the cache, so look it up from SWIG
2723 name.Append(wxT(" *"));
2724 swigType = SWIG_TypeQuery(name.mb_str());
2725
2726 // if it still wasn't found, try looking for a mapped name
2727 if (!swigType) {
2728 PyObject* item;
2729 name = className;
2730
2731 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2732 (char*)(const char*)name.mbc_str())) != NULL) {
2733 name = wxString(PyString_AsString(item), *wxConvCurrent);
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736 }
2737 }
2738 if (swigType) {
2739 // and add it to the map if found
2740 (*typeInfoCache)[className] = swigType;
2741 }
2742 }
2743 return swigType;
2744 }
2745
2746
2747 // Check if a class name is a type known to SWIG
2748 bool wxPyCheckSwigType(const wxChar* className) {
2749
2750 swig_type_info* swigType = wxPyFindSwigType(className);
2751 return swigType != NULL;
2752 }
2753
2754
2755 // Given a pointer to a C++ object and a class name, construct a Python proxy
2756 // object for it.
2757 PyObject* wxPyConstructObject(void* ptr,
2758 const wxChar* className,
2759 int setThisOwn) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2763
2764 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2765 }
2766
2767
2768 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2769 // Ensures that the proxy object is of the specified (or derived) type. If
2770 // not able to perform the conversion then a Python exception is set and the
2771 // error should be handled properly in the caller. Returns True on success.
2772 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2773 const wxChar* className) {
2774
2775 swig_type_info* swigType = wxPyFindSwigType(className);
2776 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2777
2778 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2779 }
2780
2781
2782
2783 // Make a SWIGified pointer object suitable for a .this attribute
2784 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2785
2786 PyObject* robj = NULL;
2787
2788 swig_type_info* swigType = wxPyFindSwigType(className);
2789 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2790
2791 robj = PySwigObject_New(ptr, swigType, 0);
2792 return robj;
2793 }
2794
2795
2796 // Python's PyInstance_Check does not return True for instances of new-style
2797 // classes. This should get close enough for both new and old classes but I
2798 // should re-evaluate the need for doing instance checks...
2799 bool wxPyInstance_Check(PyObject* obj) {
2800 return PyObject_HasAttrString(obj, "__class__") != 0;
2801 }
2802
2803
2804 // This one checks if the object is an instance of a SWIG proxy class (it has
2805 // a .this attribute, and the .this attribute is a PySwigObject.)
2806 bool wxPySwigInstance_Check(PyObject* obj) {
2807 static PyObject* this_str = NULL;
2808 if (this_str == NULL)
2809 this_str = PyString_FromString("this");
2810
2811 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2812 if (this_attr) {
2813 bool retval = (PySwigObject_Check(this_attr) != 0);
2814 Py_DECREF(this_attr);
2815 return retval;
2816 }
2817
2818 PyErr_Clear();
2819 return false;
2820 }
2821
2822
2823 // Export a C API in a struct. Other modules will be able to load this from
2824 // the wx._core_ module and will then have safe access to these functions,
2825 // even if they are located in another shared library.
2826 static wxPyCoreAPI API = {
2827
2828 wxPyCheckSwigType,
2829 wxPyConstructObject,
2830 wxPyConvertSwigPtr,
2831 wxPyMakeSwigPtr,
2832
2833 wxPyBeginAllowThreads,
2834 wxPyEndAllowThreads,
2835 wxPyBeginBlockThreads,
2836 wxPyEndBlockThreads,
2837
2838 wxPy_ConvertList,
2839
2840 wxString_in_helper,
2841 Py2wxString,
2842 wx2PyString,
2843
2844 byte_LIST_helper,
2845 int_LIST_helper,
2846 long_LIST_helper,
2847 string_LIST_helper,
2848 wxPoint_LIST_helper,
2849 wxBitmap_LIST_helper,
2850 wxString_LIST_helper,
2851 wxAcceleratorEntry_LIST_helper,
2852
2853 wxSize_helper,
2854 wxPoint_helper,
2855 wxRealPoint_helper,
2856 wxRect_helper,
2857 wxColour_helper,
2858 wxPoint2D_helper,
2859
2860 wxPySimple_typecheck,
2861 wxColour_typecheck,
2862
2863 wxPyCBH_setCallbackInfo,
2864 wxPyCBH_findCallback,
2865 wxPyCBH_callCallback,
2866 wxPyCBH_callCallbackObj,
2867 wxPyCBH_delete,
2868
2869 wxPyMake_wxObject,
2870 wxPyMake_wxSizer,
2871 wxPyPtrTypeMap_Add,
2872 wxPy2int_seq_helper,
2873 wxPy4int_seq_helper,
2874 wxArrayString2PyList_helper,
2875 wxArrayInt2PyList_helper,
2876
2877 wxPyClientData_dtor,
2878 wxPyUserData_dtor,
2879 wxPyOORClientData_dtor,
2880
2881 wxPyCBInputStream_create,
2882 wxPyCBInputStream_copy,
2883
2884 wxPyInstance_Check,
2885 wxPySwigInstance_Check,
2886
2887 wxPyCheckForApp
2888
2889 };
2890
2891 #endif
2892
2893
2894 #if !WXWIN_COMPATIBILITY_2_4
2895 #define wxHIDE_READONLY 0
2896 #endif
2897
2898
2899 #define SWIG_From_long PyInt_FromLong
2900
2901
2902 SWIGINTERNINLINE PyObject *
2903 SWIG_From_int (int value)
2904 {
2905 return SWIG_From_long (value);
2906 }
2907
2908 static const wxString wxPyEmptyString(wxEmptyString);
2909 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2910 return self->GetClassInfo()->GetClassName();
2911 }
2912 SWIGINTERN void wxObject_Destroy(wxObject *self){
2913 delete self;
2914 }
2915
2916 #ifndef __WXMAC__
2917 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2918 #endif
2919
2920
2921 #include <limits.h>
2922 #ifndef LLONG_MIN
2923 # define LLONG_MIN LONG_LONG_MIN
2924 #endif
2925 #ifndef LLONG_MAX
2926 # define LLONG_MAX LONG_LONG_MAX
2927 #endif
2928 #ifndef ULLONG_MAX
2929 # define ULLONG_MAX ULONG_LONG_MAX
2930 #endif
2931
2932
2933 SWIGINTERN int
2934 SWIG_AsVal_long (PyObject* obj, long* val)
2935 {
2936 if (PyNumber_Check(obj)) {
2937 if (val) *val = PyInt_AsLong(obj);
2938 return SWIG_OK;
2939 }
2940 return SWIG_TypeError;
2941 }
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_int (PyObject * obj, int *val)
2946 {
2947 long v;
2948 int res = SWIG_AsVal_long (obj, &v);
2949 if (SWIG_IsOK(res)) {
2950 if ((v < INT_MIN || v > INT_MAX)) {
2951 return SWIG_OverflowError;
2952 } else {
2953 if (val) *val = static_cast< int >(v);
2954 }
2955 }
2956 return res;
2957 }
2958
2959 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2960 wxSize temp, *obj = &temp;
2961 if ( other == Py_None ) return false;
2962 if ( ! wxSize_helper(other, &obj) ) {
2963 PyErr_Clear();
2964 return false;
2965 }
2966 return self->operator==(*obj);
2967 }
2968 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2969 wxSize temp, *obj = &temp;
2970 if ( other == Py_None ) return true;
2971 if ( ! wxSize_helper(other, &obj)) {
2972 PyErr_Clear();
2973 return true;
2974 }
2975 return self->operator!=(*obj);
2976 }
2977 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 PyObject* tup = PyTuple_New(2);
2980 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2981 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2982 wxPyEndBlockThreads(blocked);
2983 return tup;
2984 }
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 #define SWIG_From_double PyFloat_FromDouble
2998
2999 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3000 wxRealPoint temp, *obj = &temp;
3001 if ( other == Py_None ) return false;
3002 if ( ! wxRealPoint_helper(other, &obj) ) {
3003 PyErr_Clear();
3004 return false;
3005 }
3006 return self->operator==(*obj);
3007 }
3008 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3009 wxRealPoint temp, *obj = &temp;
3010 if ( other == Py_None ) return true;
3011 if ( ! wxRealPoint_helper(other, &obj)) {
3012 PyErr_Clear();
3013 return true;
3014 }
3015 return self->operator!=(*obj);
3016 }
3017 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3018 self->x = x;
3019 self->y = y;
3020 }
3021 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3026 wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3030 wxPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3039 wxPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3056 wxPyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3060 wxRect temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxRect_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3069 wxRect temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxRect_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3078 self->x = x;
3079 self->y = y;
3080 self->width = width;
3081 self->height = height;
3082 }
3083 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(4);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3089 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3090 wxPyEndBlockThreads(blocked);
3091 return tup;
3092 }
3093
3094 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3095 wxRegion reg1(*r1);
3096 wxRegion reg2(*r2);
3097 wxRect dest(0,0,0,0);
3098 PyObject* obj;
3099
3100 reg1.Intersect(reg2);
3101 dest = reg1.GetBox();
3102
3103 if (dest != wxRect(0,0,0,0)) {
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxRect* newRect = new wxRect(dest);
3106 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3107 wxPyEndBlockThreads(blocked);
3108 return obj;
3109 }
3110 Py_INCREF(Py_None);
3111 return Py_None;
3112 }
3113
3114 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3115 wxPoint2D temp, *obj = &temp;
3116 if ( other == Py_None ) return false;
3117 if ( ! wxPoint2D_helper(other, &obj) ) {
3118 PyErr_Clear();
3119 return false;
3120 }
3121 return self->operator==(*obj);
3122 }
3123 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3124 wxPoint2D temp, *obj = &temp;
3125 if ( other == Py_None ) return true;
3126 if ( ! wxPoint2D_helper(other, &obj)) {
3127 PyErr_Clear();
3128 return true;
3129 }
3130 return self->operator!=(*obj);
3131 }
3132 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3133 self->m_x = x;
3134 self->m_y = y;
3135 }
3136 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 PyObject* tup = PyTuple_New(2);
3139 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3140 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3141 wxPyEndBlockThreads(blocked);
3142 return tup;
3143 }
3144
3145 #include "wx/wxPython/pyistream.h"
3146
3147 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3148 wxInputStream* wxis = wxPyCBInputStream::create(p);
3149 if (wxis)
3150 return new wxPyInputStream(wxis);
3151 else
3152 return NULL;
3153 }
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_From_char (char c)
3187 {
3188 return SWIG_FromCharPtrAndSize(&c,1);
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject*
3193 SWIG_From_unsigned_SS_long (unsigned long value)
3194 {
3195 return (value > LONG_MAX) ?
3196 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3197 }
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_size_t (size_t value)
3202 {
3203 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3204 }
3205
3206
3207 SWIGINTERN int
3208 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3209 {
3210 if (PyString_Check(obj)) {
3211 char *cstr; int len;
3212 PyString_AsStringAndSize(obj, &cstr, &len);
3213 if (cptr) {
3214 if (alloc) {
3215 /*
3216 In python the user should not be able to modify the inner
3217 string representation. To warranty that, if you define
3218 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3219 buffer is always returned.
3220
3221 The default behavior is just to return the pointer value,
3222 so, be careful.
3223 */
3224 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3225 if (*alloc != SWIG_OLDOBJ)
3226 #else
3227 if (*alloc == SWIG_NEWOBJ)
3228 #endif
3229 {
3230 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3231 *alloc = SWIG_NEWOBJ;
3232 }
3233 else {
3234 *cptr = cstr;
3235 *alloc = SWIG_OLDOBJ;
3236 }
3237 } else {
3238 *cptr = PyString_AsString(obj);
3239 }
3240 }
3241 if (psize) *psize = len + 1;
3242 return SWIG_OK;
3243 } else {
3244 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3245 if (pchar_descriptor) {
3246 void* vptr = 0;
3247 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3248 if (cptr) *cptr = (char *) vptr;
3249 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3250 if (alloc) *alloc = SWIG_OLDOBJ;
3251 return SWIG_OK;
3252 }
3253 }
3254 }
3255 return SWIG_TypeError;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3261 {
3262 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3263 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3264 if (SWIG_IsOK(res)) {
3265 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3266 if (csize <= size) {
3267 if (val) {
3268 if (csize) memcpy(val, cptr, csize*sizeof(char));
3269 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3270 }
3271 if (alloc == SWIG_NEWOBJ) {
3272 delete[] cptr;
3273 res = SWIG_DelNewMask(res);
3274 }
3275 return res;
3276 }
3277 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsVal_char (PyObject * obj, char *val)
3285 {
3286 int res = SWIG_AsCharArray(obj, val, 1);
3287 if (!SWIG_IsOK(res)) {
3288 long v;
3289 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3290 if (SWIG_IsOK(res)) {
3291 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3292 if (val) *val = static_cast< char >(v);
3293 } else {
3294 res = SWIG_OverflowError;
3295 }
3296 }
3297 }
3298 return res;
3299 }
3300
3301 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3302 // We use only strings for the streams, not unicode
3303 PyObject* str = PyObject_Str(obj);
3304 if (! str) {
3305 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3306 return;
3307 }
3308 self->Write(PyString_AS_STRING(str),
3309 PyString_GET_SIZE(str));
3310 Py_DECREF(str);
3311 }
3312
3313 #include "wx/wxPython/pyistream.h"
3314
3315
3316 class wxPyFileSystemHandler : public wxFileSystemHandler
3317 {
3318 public:
3319 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3320
3321 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3322 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3323 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3324 DEC_PYCALLBACK_STRING__pure(FindNext);
3325
3326 wxString GetProtocol(const wxString& location) {
3327 return wxFileSystemHandler::GetProtocol(location);
3328 }
3329
3330 wxString GetLeftLocation(const wxString& location) {
3331 return wxFileSystemHandler::GetLeftLocation(location);
3332 }
3333
3334 wxString GetAnchor(const wxString& location) {
3335 return wxFileSystemHandler::GetAnchor(location);
3336 }
3337
3338 wxString GetRightLocation(const wxString& location) {
3339 return wxFileSystemHandler::GetRightLocation(location);
3340 }
3341
3342 wxString GetMimeTypeFromExt(const wxString& location) {
3343 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3344 }
3345
3346 PYPRIVATE;
3347 };
3348
3349
3350 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3351 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3352 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3353 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3354
3355
3356 SWIGINTERN int
3357 SWIG_AsVal_bool (PyObject *obj, bool *val)
3358 {
3359 if (obj == Py_True) {
3360 if (val) *val = true;
3361 return SWIG_OK;
3362 } else if (obj == Py_False) {
3363 if (val) *val = false;
3364 return SWIG_OK;
3365 } else {
3366 long v = 0;
3367 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3368 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3369 return res;
3370 }
3371 }
3372
3373 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3374 wxFileName fname = wxFileSystem::URLToFileName(url);
3375 return fname.GetFullPath();
3376 }
3377
3378 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3379 wxImage& image,
3380 long type) {
3381 wxMemoryFSHandler::AddFile(filename, image, type);
3382 }
3383
3384 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3385 const wxBitmap& bitmap,
3386 long type) {
3387 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3388 }
3389
3390 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3391 PyObject* data) {
3392 if (! PyString_Check(data)) {
3393 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3394 "Expected string object"));
3395 return;
3396 }
3397
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 void* ptr = (void*)PyString_AsString(data);
3400 size_t size = PyString_Size(data);
3401 wxPyEndBlockThreads(blocked);
3402
3403 wxMemoryFSHandler::AddFile(filename, ptr, size);
3404 }
3405
3406
3407 #include "wx/wxPython/pyistream.h"
3408
3409
3410 SWIGINTERN int
3411 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3412 {
3413 long v = 0;
3414 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3415 return SWIG_TypeError;
3416 }
3417 else if (val)
3418 *val = (unsigned long)v;
3419 return SWIG_OK;
3420 }
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3425 {
3426 unsigned long v;
3427 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3428 if (SWIG_IsOK(res)) {
3429 if ((v > UCHAR_MAX)) {
3430 return SWIG_OverflowError;
3431 } else {
3432 if (val) *val = static_cast< unsigned char >(v);
3433 }
3434 }
3435 return res;
3436 }
3437
3438
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442 return SWIG_From_unsigned_SS_long (value);
3443 }
3444
3445 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3446 wxImageHistogramEntry e = (*self)[key];
3447 return e.value;
3448 }
3449 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3451 wxImageHistogramEntry e = (*self)[key];
3452 return e.value;
3453 }
3454 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3456 colour.Green(),
3457 colour.Blue());
3458 wxImageHistogramEntry e = (*self)[key];
3459 return e.value;
3460 }
3461
3462 typedef unsigned char* buffer;
3463
3464
3465 // Pull the nested class out to the top level for SWIG's sake
3466 #define wxImage_RGBValue wxImage::RGBValue
3467 #define wxImage_HSVValue wxImage::HSVValue
3468
3469 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3470 if (width > 0 && height > 0)
3471 return new wxImage(width, height, clear);
3472 else
3473 return new wxImage;
3474 }
3475 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3476 return new wxImage(bitmap.ConvertToImage());
3477 }
3478 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3479 if (DATASIZE != width*height*3) {
3480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3481 return NULL;
3482 }
3483
3484 // Copy the source data so the wxImage can clean it up later
3485 buffer copy = (buffer)malloc(DATASIZE);
3486 if (copy == NULL) {
3487 wxPyBLOCK_THREADS(PyErr_NoMemory());
3488 return NULL;
3489 }
3490 memcpy(copy, data, DATASIZE);
3491 return new wxImage(width, height, copy, false);
3492 }
3493 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3494 if (DATASIZE != width*height*3) {
3495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3496 return NULL;
3497 }
3498 if (ALPHASIZE != width*height) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3500 return NULL;
3501 }
3502
3503 // Copy the source data so the wxImage can clean it up later
3504 buffer dcopy = (buffer)malloc(DATASIZE);
3505 if (dcopy == NULL) {
3506 wxPyBLOCK_THREADS(PyErr_NoMemory());
3507 return NULL;
3508 }
3509 memcpy(dcopy, data, DATASIZE);
3510
3511 buffer acopy = (buffer)malloc(ALPHASIZE);
3512 if (acopy == NULL) {
3513 wxPyBLOCK_THREADS(PyErr_NoMemory());
3514 return NULL;
3515 }
3516 memcpy(acopy, alpha, ALPHASIZE);
3517
3518 return new wxImage(width, height, dcopy, acopy, false);
3519 }
3520 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3521 wxSize size(self->GetWidth(), self->GetHeight());
3522 return size;
3523 }
3524 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3525 buffer data = self->GetData();
3526 int len = self->GetWidth() * self->GetHeight() * 3;
3527 PyObject* rv;
3528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3529 return rv;
3530 }
3531 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3534 return;
3535 }
3536 buffer copy = (buffer)malloc(DATASIZE);
3537 if (copy == NULL) {
3538 wxPyBLOCK_THREADS(PyErr_NoMemory());
3539 return;
3540 }
3541 memcpy(copy, data, DATASIZE);
3542 self->SetData(copy, false);
3543 // wxImage takes ownership of copy...
3544 }
3545 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 self->SetData(data, true);
3558 }
3559 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3560 buffer data = self->GetAlpha();
3561 if (! data) {
3562 RETURN_NONE();
3563 } else {
3564 int len = self->GetWidth() * self->GetHeight();
3565 PyObject* rv;
3566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3567 return rv;
3568 }
3569 }
3570 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3573 return;
3574 }
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581 self->SetAlpha(acopy, false);
3582 // wxImage takes ownership of acopy...
3583 }
3584 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3585 buffer data = self->GetAlpha();
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3589 return rv;
3590 }
3591 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 self->SetAlpha(alpha, true);
3597 }
3598 SWIGINTERN PyObject *wxImage_GetHandlers(){
3599 wxList& list = wxImage::GetHandlers();
3600 return wxPy_ConvertList(&list);
3601 }
3602 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3603 wxBitmap bitmap(*self, depth);
3604 return bitmap;
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3607 wxImage mono = self->ConvertToMono( red, green, blue );
3608 wxBitmap bitmap( mono, 1 );
3609 return bitmap;
3610 }
3611 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3612 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3614 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3618 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3619 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3620 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3621 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3622 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3623 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3624 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3625 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3626
3627 #include <wx/quantize.h>
3628
3629 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3630 return wxQuantize::Quantize(src, dest,
3631 //NULL, // palette
3632 desiredNoColours,
3633 NULL, // eightBitData
3634 flags);
3635 }
3636 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3637 if (PyCallable_Check(func)) {
3638 self->Connect(id, lastId, eventType,
3639 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3640 new wxPyCallback(func));
3641 }
3642 else if (func == Py_None) {
3643 self->Disconnect(id, lastId, eventType,
3644 (wxObjectEventFunction)
3645 &wxPyCallback::EventThunker);
3646 }
3647 else {
3648 wxPyBLOCK_THREADS(
3649 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3650 }
3651 }
3652 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3653 return self->Disconnect(id, lastId, eventType,
3654 (wxObjectEventFunction)
3655 &wxPyCallback::EventThunker);
3656 }
3657 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3658 if (_self && _self != Py_None) {
3659 self->SetClientObject(new wxPyOORClientData(_self, incref));
3660 }
3661 else {
3662 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3663 if (data) {
3664 self->SetClientObject(NULL); // This will delete it too
3665 }
3666 }
3667 }
3668
3669 #if ! wxUSE_HOTKEY
3670 #define wxEVT_HOTKEY -9999
3671 #endif
3672
3673 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3674 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3675 if (data) {
3676 Py_INCREF(data->m_obj);
3677 return data->m_obj;
3678 } else {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 }
3683 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3684 wxPyClientData* data = new wxPyClientData(clientData);
3685 self->SetClientObject(data);
3686 }
3687 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3688 #if wxUSE_UNICODE
3689 return self->GetUnicodeKey();
3690 #else
3691 return 0;
3692 #endif
3693 }
3694 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3695 #if wxUSE_UNICODE
3696 self->m_uniChar = uniChar;
3697 #endif
3698 }
3699
3700 SWIGINTERNINLINE PyObject *
3701 SWIG_From_unsigned_SS_int (unsigned int value)
3702 {
3703 return SWIG_From_unsigned_SS_long (value);
3704 }
3705
3706
3707 SWIGINTERN int
3708 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3709 {
3710 unsigned long v;
3711 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3712 if (SWIG_IsOK(res)) {
3713 if ((v > UINT_MAX)) {
3714 return SWIG_OverflowError;
3715 } else {
3716 if (val) *val = static_cast< unsigned int >(v);
3717 }
3718 }
3719 return res;
3720 }
3721
3722 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3723 self->m_size = size;
3724 }
3725 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3726 int count = self->GetNumberOfFiles();
3727 wxString* files = self->GetFiles();
3728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3729 PyObject* list = PyList_New(count);
3730
3731 if (!list) {
3732 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3733 wxPyEndBlockThreads(blocked);
3734 return NULL;
3735 }
3736
3737 for (int i=0; i<count; i++) {
3738 PyList_SetItem(list, i, wx2PyString(files[i]));
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 return list;
3742 }
3743
3744
3745 SWIGINTERN wxPyApp *new_wxPyApp(){
3746 wxPythonApp = new wxPyApp();
3747 return wxPythonApp;
3748 }
3749
3750 void wxApp_CleanUp() {
3751 __wxPyCleanup();
3752 }
3753
3754
3755 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3756
3757
3758
3759
3760
3761 SWIGINTERNINLINE PyObject *
3762 SWIG_FromCharPtr(const char *cptr)
3763 {
3764 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3765 }
3766
3767
3768 #if 0 // #ifdef __WXMAC__
3769
3770 // A dummy class that raises an exception if used...
3771 class wxEventLoop
3772 {
3773 public:
3774 wxEventLoop() { wxPyRaiseNotImplemented(); }
3775 int Run() { return 0; }
3776 void Exit(int rc = 0) {}
3777 bool Pending() const { return false; }
3778 bool Dispatch() { return false; }
3779 bool IsRunning() const { return false; }
3780 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3781 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3782 };
3783
3784 #else
3785
3786 #include <wx/evtloop.h>
3787
3788 #endif
3789
3790
3791
3792 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3793 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3794 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3795 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3796 wxWindowList& list = self->GetChildren();
3797 return wxPy_ConvertList(&list);
3798 }
3799 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3800 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3801 #if wxUSE_HOTKEY
3802 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3803 #else
3804 return false;
3805 #endif
3806 }
3807 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3808
3809
3810
3811 return false;
3812
3813 }
3814 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3815 return wxPyGetWinHandle(self);
3816 }
3817 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3818 self->AssociateHandle((WXWidget)handle);
3819 }
3820
3821 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3822 return wxWindow::FindWindowById(id, parent);
3823 }
3824
3825 wxWindow* wxFindWindowByName( const wxString& name,
3826 const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowByName(name, parent);
3828 }
3829
3830 wxWindow* wxFindWindowByLabel( const wxString& label,
3831 const wxWindow *parent = NULL ) {
3832 return wxWindow::FindWindowByLabel(label, parent);
3833 }
3834
3835
3836 #ifdef __WXMSW__
3837 #include <wx/msw/private.h> // to get wxGetWindowId
3838 #endif
3839
3840
3841 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3842 #ifdef __WXMSW__
3843 WXHWND hWnd = (WXHWND)_hWnd;
3844 long id = wxGetWindowId(hWnd);
3845 wxWindow* win = new wxWindow;
3846 if (parent)
3847 parent->AddChild(win);
3848 win->SetEventHandler(win);
3849 win->SetHWND(hWnd);
3850 win->SetId(id);
3851 win->SubclassWin(hWnd);
3852 win->AdoptAttributesFromHWND();
3853 win->SetupColours();
3854 return win;
3855 #else
3856 wxPyRaiseNotImplemented();
3857 return NULL;
3858 #endif
3859 }
3860
3861
3862 PyObject* GetTopLevelWindows() {
3863 return wxPy_ConvertList(&wxTopLevelWindows);
3864 }
3865
3866
3867 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3868 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3869 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3870
3871 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3872
3873
3874 SWIGINTERNINLINE int
3875 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3876 {
3877 unsigned long v;
3878 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3879 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3880 return res;
3881 }
3882
3883 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3884 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3885 wxMenuItemList& list = self->GetMenuItems();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3889 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3890 static const wxString wxPyControlNameStr(wxControlNameStr);
3891 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3892 if (clientData) {
3893 wxPyClientData* data = new wxPyClientData(clientData);
3894 return self->Append(item, data);
3895 } else
3896 return self->Append(item);
3897 }
3898 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3899 if (clientData) {
3900 wxPyClientData* data = new wxPyClientData(clientData);
3901 return self->Insert(item, pos, data);
3902 } else
3903 return self->Insert(item, pos);
3904 }
3905 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3906 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3907 if (data) {
3908 Py_INCREF(data->m_obj);
3909 return data->m_obj;
3910 } else {
3911 Py_INCREF(Py_None);
3912 return Py_None;
3913 }
3914 }
3915 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3916 wxPyClientData* data = new wxPyClientData(clientData);
3917 self->SetClientObject(n, data);
3918 }
3919
3920
3921 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3922 wxPyUserData* data = NULL;
3923 if ( userData ) {
3924 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3925 data = new wxPyUserData(userData);
3926 wxPyEndBlockThreads(blocked);
3927 }
3928 return new wxSizerItem(window, proportion, flag, border, data);
3929 }
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3931 wxPyUserData* data = NULL;
3932 if ( userData ) {
3933 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3934 data = new wxPyUserData(userData);
3935 wxPyEndBlockThreads(blocked);
3936 }
3937 return new wxSizerItem(width, height, proportion, flag, border, data);
3938 }
3939 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3940 wxPyUserData* data = NULL;
3941 if ( userData ) {
3942 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3943 data = new wxPyUserData(userData);
3944 wxPyEndBlockThreads(blocked);
3945 }
3946 return new wxSizerItem(sizer, proportion, flag, border, data);
3947 }
3948
3949 #include <float.h>
3950
3951
3952 SWIGINTERN int
3953 SWIG_AsVal_float (PyObject * obj, float *val)
3954 {
3955 double v;
3956 int res = SWIG_AsVal_double (obj, &v);
3957 if (SWIG_IsOK(res)) {
3958 if ((v < -FLT_MAX || v > FLT_MAX)) {
3959 return SWIG_OverflowError;
3960 } else {
3961 if (val) *val = static_cast< float >(v);
3962 }
3963 }
3964 return res;
3965 }
3966
3967
3968 SWIGINTERNINLINE PyObject *
3969 SWIG_From_float (float value)
3970 {
3971 return SWIG_From_double (value);
3972 }
3973
3974 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3975 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3976 if (data) {
3977 Py_INCREF(data->m_obj);
3978 return data->m_obj;
3979 } else {
3980 Py_INCREF(Py_None);
3981 return Py_None;
3982 }
3983 }
3984 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3985 wxPyUserData* data = NULL;
3986 if ( userData ) {
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 data = new wxPyUserData(userData);
3989 wxPyEndBlockThreads(blocked);
3990 }
3991 self->SetUserData(data);
3992 }
3993
3994 // Figure out the type of the sizer item
3995
3996 struct wxPySizerItemInfo {
3997 wxPySizerItemInfo()
3998 : window(NULL), sizer(NULL), gotSize(false),
3999 size(wxDefaultSize), gotPos(false), pos(-1)
4000 {}
4001
4002 wxWindow* window;
4003 wxSizer* sizer;
4004 bool gotSize;
4005 wxSize size;
4006 bool gotPos;
4007 int pos;
4008 };
4009
4010 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4011
4012 wxPySizerItemInfo info;
4013 wxSize size;
4014 wxSize* sizePtr = &size;
4015
4016 // Find out what the type of the item is
4017 // try wxWindow
4018 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4019 PyErr_Clear();
4020 info.window = NULL;
4021
4022 // try wxSizer
4023 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4024 PyErr_Clear();
4025 info.sizer = NULL;
4026
4027 // try wxSize or (w,h)
4028 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4029 info.size = *sizePtr;
4030 info.gotSize = true;
4031 }
4032
4033 // or a single int
4034 if (checkIdx && PyInt_Check(item)) {
4035 info.pos = PyInt_AsLong(item);
4036 info.gotPos = true;
4037 }
4038 }
4039 }
4040
4041 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4042 // no expected type, figure out what kind of error message to generate
4043 if ( !checkSize && !checkIdx )
4044 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4045 else if ( checkSize && !checkIdx )
4046 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4047 else if ( !checkSize && checkIdx)
4048 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4049 else
4050 // can this one happen?
4051 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4052 }
4053
4054 return info;
4055 }
4056
4057 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4058 if (!self->GetClientObject())
4059 self->SetClientObject(new wxPyOORClientData(_self));
4060 }
4061 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4062
4063 wxPyUserData* data = NULL;
4064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4066 if ( userData && (info.window || info.sizer || info.gotSize) )
4067 data = new wxPyUserData(userData);
4068 if ( info.sizer )
4069 PyObject_SetAttrString(item,"thisown",Py_False);
4070 wxPyEndBlockThreads(blocked);
4071
4072 // Now call the real Add method if a valid item type was found
4073 if ( info.window )
4074 return self->Add(info.window, proportion, flag, border, data);
4075 else if ( info.sizer )
4076 return self->Add(info.sizer, proportion, flag, border, data);
4077 else if (info.gotSize)
4078 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4079 proportion, flag, border, data);
4080 else
4081 return NULL;
4082 }
4083 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4084
4085 wxPyUserData* data = NULL;
4086 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4088 if ( userData && (info.window || info.sizer || info.gotSize) )
4089 data = new wxPyUserData(userData);
4090 if ( info.sizer )
4091 PyObject_SetAttrString(item,"thisown",Py_False);
4092 wxPyEndBlockThreads(blocked);
4093
4094 // Now call the real Insert method if a valid item type was found
4095 if ( info.window )
4096 return self->Insert(before, info.window, proportion, flag, border, data);
4097 else if ( info.sizer )
4098 return self->Insert(before, info.sizer, proportion, flag, border, data);
4099 else if (info.gotSize)
4100 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4101 proportion, flag, border, data);
4102 else
4103 return NULL;
4104 }
4105 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4106
4107 wxPyUserData* data = NULL;
4108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4109 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4110 if ( userData && (info.window || info.sizer || info.gotSize) )
4111 data = new wxPyUserData(userData);
4112 if ( info.sizer )
4113 PyObject_SetAttrString(item,"thisown",Py_False);
4114 wxPyEndBlockThreads(blocked);
4115
4116 // Now call the real Prepend method if a valid item type was found
4117 if ( info.window )
4118 return self->Prepend(info.window, proportion, flag, border, data);
4119 else if ( info.sizer )
4120 return self->Prepend(info.sizer, proportion, flag, border, data);
4121 else if (info.gotSize)
4122 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4123 proportion, flag, border, data);
4124 else
4125 return NULL;
4126 }
4127 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4130 wxPyEndBlockThreads(blocked);
4131 if ( info.window )
4132 return self->Remove(info.window);
4133 else if ( info.sizer )
4134 return self->Remove(info.sizer);
4135 else if ( info.gotPos )
4136 return self->Remove(info.pos);
4137 else
4138 return false;
4139 }
4140 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4143 wxPyEndBlockThreads(blocked);
4144 if ( info.window )
4145 return self->Detach(info.window);
4146 else if ( info.sizer )
4147 return self->Detach(info.sizer);
4148 else if ( info.gotPos )
4149 return self->Detach(info.pos);
4150 else
4151 return false;
4152 }
4153 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4156 wxPyEndBlockThreads(blocked);
4157 if ( info.window )
4158 return self->GetItem(info.window);
4159 else if ( info.sizer )
4160 return self->GetItem(info.sizer);
4161 else if ( info.gotPos )
4162 return self->GetItem(info.pos);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 self->SetItemMinSize(info.window, size);
4172 else if ( info.sizer )
4173 self->SetItemMinSize(info.sizer, size);
4174 else if ( info.gotPos )
4175 self->SetItemMinSize(info.pos, size);
4176 }
4177 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4178 wxSizerItemList& list = self->GetChildren();
4179 return wxPy_ConvertList(&list);
4180 }
4181 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 return self->Show(info.window, show, recursive);
4187 else if ( info.sizer )
4188 return self->Show(info.sizer, show, recursive);
4189 else if ( info.gotPos )
4190 return self->Show(info.pos, show);
4191 else
4192 return false;
4193 }
4194 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4197 wxPyEndBlockThreads(blocked);
4198 if ( info.window )
4199 return self->IsShown(info.window);
4200 else if ( info.sizer )
4201 return self->IsShown(info.sizer);
4202 else if ( info.gotPos )
4203 return self->IsShown(info.pos);
4204 else
4205 return false;
4206 }
4207
4208 // See pyclasses.h
4209 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4210 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4211 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4212
4213
4214
4215
4216 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4217 {
4218 if (source == Py_None) {
4219 **obj = wxGBPosition(-1,-1);
4220 return true;
4221 }
4222 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4223 }
4224
4225 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4226 {
4227 if (source == Py_None) {
4228 **obj = wxGBSpan(-1,-1);
4229 return true;
4230 }
4231 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4232 }
4233
4234
4235 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4236 wxGBPosition temp, *obj = &temp;
4237 if ( other == Py_None ) return false;
4238 if ( ! wxGBPosition_helper(other, &obj) ) {
4239 PyErr_Clear();
4240 return false;
4241 }
4242 return self->operator==(*obj);
4243 }
4244 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4245 wxGBPosition temp, *obj = &temp;
4246 if ( other == Py_None ) return true;
4247 if ( ! wxGBPosition_helper(other, &obj)) {
4248 PyErr_Clear();
4249 return true;
4250 }
4251 return self->operator!=(*obj);
4252 }
4253 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4254 self->SetRow(row);
4255 self->SetCol(col);
4256 }
4257 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4258 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4259 PyObject* tup = PyTuple_New(2);
4260 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4261 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4262 wxPyEndBlockThreads(blocked);
4263 return tup;
4264 }
4265 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4266 wxGBSpan temp, *obj = &temp;
4267 if ( other == Py_None ) return false;
4268 if ( ! wxGBSpan_helper(other, &obj) ) {
4269 PyErr_Clear();
4270 return false;
4271 }
4272 return self->operator==(*obj);
4273 }
4274 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4275 wxGBSpan temp, *obj = &temp;
4276 if ( other == Py_None ) return true;
4277 if ( ! wxGBSpan_helper(other, &obj)) {
4278 PyErr_Clear();
4279 return true;
4280 }
4281 return self->operator!=(*obj);
4282 }
4283 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4284 self->SetRowspan(rowspan);
4285 self->SetColspan(colspan);
4286 }
4287 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4289 PyObject* tup = PyTuple_New(2);
4290 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4291 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4292 wxPyEndBlockThreads(blocked);
4293 return tup;
4294 }
4295 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4296 wxPyUserData* data = NULL;
4297 if ( userData ) {
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 data = new wxPyUserData(userData);
4300 wxPyEndBlockThreads(blocked);
4301 }
4302 return new wxGBSizerItem(window, pos, span, flag, border, data);
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4305 wxPyUserData* data = NULL;
4306 if ( userData ) {
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 data = new wxPyUserData(userData);
4309 wxPyEndBlockThreads(blocked);
4310 }
4311 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4314 wxPyUserData* data = NULL;
4315 if ( userData ) {
4316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4317 data = new wxPyUserData(userData);
4318 wxPyEndBlockThreads(blocked);
4319 }
4320 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4321 }
4322 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4323 int row, col;
4324 self->GetEndPos(row, col);
4325 return wxGBPosition(row, col);
4326 }
4327 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4328
4329 wxPyUserData* data = NULL;
4330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4331 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4332 if ( userData && (info.window || info.sizer || info.gotSize) )
4333 data = new wxPyUserData(userData);
4334 if ( info.sizer )
4335 PyObject_SetAttrString(item,"thisown",Py_False);
4336 wxPyEndBlockThreads(blocked);
4337
4338 // Now call the real Add method if a valid item type was found
4339 if ( info.window )
4340 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4341 else if ( info.sizer )
4342 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4343 else if (info.gotSize)
4344 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4345 pos, span, flag, border, data);
4346 return NULL;
4347 }
4348
4349
4350 #ifdef __cplusplus
4351 extern "C" {
4352 #endif
4353 SWIGINTERN int EmptyString_set(PyObject *) {
4354 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4355 return 1;
4356 }
4357
4358
4359 SWIGINTERN PyObject *EmptyString_get(void) {
4360 PyObject *pyobj = 0;
4361
4362 {
4363 #if wxUSE_UNICODE
4364 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4365 #else
4366 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4367 #endif
4368 }
4369 return pyobj;
4370 }
4371
4372
4373 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4374 PyObject *resultobj = 0;
4375 wxObject *arg1 = (wxObject *) 0 ;
4376 wxString result;
4377 void *argp1 = 0 ;
4378 int res1 = 0 ;
4379 PyObject *swig_obj[1] ;
4380
4381 if (!args) SWIG_fail;
4382 swig_obj[0] = args;
4383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4384 if (!SWIG_IsOK(res1)) {
4385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4386 }
4387 arg1 = reinterpret_cast< wxObject * >(argp1);
4388 {
4389 PyThreadState* __tstate = wxPyBeginAllowThreads();
4390 result = wxObject_GetClassName(arg1);
4391 wxPyEndAllowThreads(__tstate);
4392 if (PyErr_Occurred()) SWIG_fail;
4393 }
4394 {
4395 #if wxUSE_UNICODE
4396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4397 #else
4398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4399 #endif
4400 }
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408 PyObject *resultobj = 0;
4409 wxObject *arg1 = (wxObject *) 0 ;
4410 void *argp1 = 0 ;
4411 int res1 = 0 ;
4412 PyObject *swig_obj[1] ;
4413
4414 if (!args) SWIG_fail;
4415 swig_obj[0] = args;
4416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4417 if (!SWIG_IsOK(res1)) {
4418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4419 }
4420 arg1 = reinterpret_cast< wxObject * >(argp1);
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 wxObject_Destroy(arg1);
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 resultobj = SWIG_Py_Void();
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4435 PyObject *obj;
4436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4437 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4438 return SWIG_Py_Void();
4439 }
4440
4441 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 wxSize *arg1 = (wxSize *) 0 ;
4444 int arg2 ;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 int val2 ;
4448 int ecode2 = 0 ;
4449 PyObject *swig_obj[2] ;
4450
4451 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4453 if (!SWIG_IsOK(res1)) {
4454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4455 }
4456 arg1 = reinterpret_cast< wxSize * >(argp1);
4457 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4458 if (!SWIG_IsOK(ecode2)) {
4459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4460 }
4461 arg2 = static_cast< int >(val2);
4462 if (arg1) (arg1)->x = arg2;
4463
4464 resultobj = SWIG_Py_Void();
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472 PyObject *resultobj = 0;
4473 wxSize *arg1 = (wxSize *) 0 ;
4474 int result;
4475 void *argp1 = 0 ;
4476 int res1 = 0 ;
4477 PyObject *swig_obj[1] ;
4478
4479 if (!args) SWIG_fail;
4480 swig_obj[0] = args;
4481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4482 if (!SWIG_IsOK(res1)) {
4483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4484 }
4485 arg1 = reinterpret_cast< wxSize * >(argp1);
4486 result = (int) ((arg1)->x);
4487 resultobj = SWIG_From_int(static_cast< int >(result));
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4495 PyObject *resultobj = 0;
4496 wxSize *arg1 = (wxSize *) 0 ;
4497 int arg2 ;
4498 void *argp1 = 0 ;
4499 int res1 = 0 ;
4500 int val2 ;
4501 int ecode2 = 0 ;
4502 PyObject *swig_obj[2] ;
4503
4504 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4511 if (!SWIG_IsOK(ecode2)) {
4512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4513 }
4514 arg2 = static_cast< int >(val2);
4515 if (arg1) (arg1)->y = arg2;
4516
4517 resultobj = SWIG_Py_Void();
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4525 PyObject *resultobj = 0;
4526 wxSize *arg1 = (wxSize *) 0 ;
4527 int result;
4528 void *argp1 = 0 ;
4529 int res1 = 0 ;
4530 PyObject *swig_obj[1] ;
4531
4532 if (!args) SWIG_fail;
4533 swig_obj[0] = args;
4534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4537 }
4538 arg1 = reinterpret_cast< wxSize * >(argp1);
4539 result = (int) ((arg1)->y);
4540 resultobj = SWIG_From_int(static_cast< int >(result));
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = 0;
4549 int arg1 = (int) 0 ;
4550 int arg2 = (int) 0 ;
4551 wxSize *result = 0 ;
4552 int val1 ;
4553 int ecode1 = 0 ;
4554 int val2 ;
4555 int ecode2 = 0 ;
4556 PyObject * obj0 = 0 ;
4557 PyObject * obj1 = 0 ;
4558 char * kwnames[] = {
4559 (char *) "w",(char *) "h", NULL
4560 };
4561
4562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4563 if (obj0) {
4564 ecode1 = SWIG_AsVal_int(obj0, &val1);
4565 if (!SWIG_IsOK(ecode1)) {
4566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4567 }
4568 arg1 = static_cast< int >(val1);
4569 }
4570 if (obj1) {
4571 ecode2 = SWIG_AsVal_int(obj1, &val2);
4572 if (!SWIG_IsOK(ecode2)) {
4573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4574 }
4575 arg2 = static_cast< int >(val2);
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (wxSize *)new wxSize(arg1,arg2);
4580 wxPyEndAllowThreads(__tstate);
4581 if (PyErr_Occurred()) SWIG_fail;
4582 }
4583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4584 return resultobj;
4585 fail:
4586 return NULL;
4587 }
4588
4589
4590 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4591 PyObject *resultobj = 0;
4592 wxSize *arg1 = (wxSize *) 0 ;
4593 void *argp1 = 0 ;
4594 int res1 = 0 ;
4595 PyObject *swig_obj[1] ;
4596
4597 if (!args) SWIG_fail;
4598 swig_obj[0] = args;
4599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4600 if (!SWIG_IsOK(res1)) {
4601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4602 }
4603 arg1 = reinterpret_cast< wxSize * >(argp1);
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 delete arg1;
4607
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 resultobj = SWIG_Py_Void();
4612 return resultobj;
4613 fail:
4614 return NULL;
4615 }
4616
4617
4618 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4619 PyObject *resultobj = 0;
4620 wxSize *arg1 = (wxSize *) 0 ;
4621 PyObject *arg2 = (PyObject *) 0 ;
4622 bool result;
4623 void *argp1 = 0 ;
4624 int res1 = 0 ;
4625 PyObject * obj0 = 0 ;
4626 PyObject * obj1 = 0 ;
4627 char * kwnames[] = {
4628 (char *) "self",(char *) "other", NULL
4629 };
4630
4631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4635 }
4636 arg1 = reinterpret_cast< wxSize * >(argp1);
4637 arg2 = obj1;
4638 {
4639 result = (bool)wxSize___eq__(arg1,arg2);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4644 }
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj = 0;
4653 wxSize *arg1 = (wxSize *) 0 ;
4654 PyObject *arg2 = (PyObject *) 0 ;
4655 bool result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 char * kwnames[] = {
4661 (char *) "self",(char *) "other", NULL
4662 };
4663
4664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4666 if (!SWIG_IsOK(res1)) {
4667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4668 }
4669 arg1 = reinterpret_cast< wxSize * >(argp1);
4670 arg2 = obj1;
4671 {
4672 result = (bool)wxSize___ne__(arg1,arg2);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 {
4676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4677 }
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4685 PyObject *resultobj = 0;
4686 wxSize *arg1 = (wxSize *) 0 ;
4687 wxSize *arg2 = 0 ;
4688 wxSize result;
4689 void *argp1 = 0 ;
4690 int res1 = 0 ;
4691 wxSize temp2 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 char * kwnames[] = {
4695 (char *) "self",(char *) "sz", NULL
4696 };
4697
4698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4700 if (!SWIG_IsOK(res1)) {
4701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4702 }
4703 arg1 = reinterpret_cast< wxSize * >(argp1);
4704 {
4705 arg2 = &temp2;
4706 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4707 }
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (arg1)->operator +((wxSize const &)*arg2);
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 wxSize *arg1 = (wxSize *) 0 ;
4724 wxSize *arg2 = 0 ;
4725 wxSize result;
4726 void *argp1 = 0 ;
4727 int res1 = 0 ;
4728 wxSize temp2 ;
4729 PyObject * obj0 = 0 ;
4730 PyObject * obj1 = 0 ;
4731 char * kwnames[] = {
4732 (char *) "self",(char *) "sz", NULL
4733 };
4734
4735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4739 }
4740 arg1 = reinterpret_cast< wxSize * >(argp1);
4741 {
4742 arg2 = &temp2;
4743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4744 }
4745 {
4746 PyThreadState* __tstate = wxPyBeginAllowThreads();
4747 result = (arg1)->operator -((wxSize const &)*arg2);
4748 wxPyEndAllowThreads(__tstate);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4752 return resultobj;
4753 fail:
4754 return NULL;
4755 }
4756
4757
4758 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj = 0;
4760 wxSize *arg1 = (wxSize *) 0 ;
4761 wxSize *arg2 = 0 ;
4762 void *argp1 = 0 ;
4763 int res1 = 0 ;
4764 wxSize temp2 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 char * kwnames[] = {
4768 (char *) "self",(char *) "sz", NULL
4769 };
4770
4771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4773 if (!SWIG_IsOK(res1)) {
4774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4775 }
4776 arg1 = reinterpret_cast< wxSize * >(argp1);
4777 {
4778 arg2 = &temp2;
4779 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4780 }
4781 {
4782 PyThreadState* __tstate = wxPyBeginAllowThreads();
4783 (arg1)->IncTo((wxSize const &)*arg2);
4784 wxPyEndAllowThreads(__tstate);
4785 if (PyErr_Occurred()) SWIG_fail;
4786 }
4787 resultobj = SWIG_Py_Void();
4788 return resultobj;
4789 fail:
4790 return NULL;
4791 }
4792
4793
4794 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4795 PyObject *resultobj = 0;
4796 wxSize *arg1 = (wxSize *) 0 ;
4797 wxSize *arg2 = 0 ;
4798 void *argp1 = 0 ;
4799 int res1 = 0 ;
4800 wxSize temp2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char * kwnames[] = {
4804 (char *) "self",(char *) "sz", NULL
4805 };
4806
4807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4809 if (!SWIG_IsOK(res1)) {
4810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4811 }
4812 arg1 = reinterpret_cast< wxSize * >(argp1);
4813 {
4814 arg2 = &temp2;
4815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 (arg1)->DecTo((wxSize const &)*arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_Py_Void();
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj = 0;
4832 wxSize *arg1 = (wxSize *) 0 ;
4833 int arg2 ;
4834 int arg3 ;
4835 void *argp1 = 0 ;
4836 int res1 = 0 ;
4837 int val2 ;
4838 int ecode2 = 0 ;
4839 int val3 ;
4840 int ecode3 = 0 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 PyObject * obj2 = 0 ;
4844 char * kwnames[] = {
4845 (char *) "self",(char *) "w",(char *) "h", NULL
4846 };
4847
4848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4852 }
4853 arg1 = reinterpret_cast< wxSize * >(argp1);
4854 ecode2 = SWIG_AsVal_int(obj1, &val2);
4855 if (!SWIG_IsOK(ecode2)) {
4856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4857 }
4858 arg2 = static_cast< int >(val2);
4859 ecode3 = SWIG_AsVal_int(obj2, &val3);
4860 if (!SWIG_IsOK(ecode3)) {
4861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4862 }
4863 arg3 = static_cast< int >(val3);
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 (arg1)->Set(arg2,arg3);
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_Py_Void();
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 wxSize *arg1 = (wxSize *) 0 ;
4880 int arg2 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 int val2 ;
4884 int ecode2 = 0 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "w", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 ecode2 = SWIG_AsVal_int(obj1, &val2);
4898 if (!SWIG_IsOK(ecode2)) {
4899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4900 }
4901 arg2 = static_cast< int >(val2);
4902 {
4903 PyThreadState* __tstate = wxPyBeginAllowThreads();
4904 (arg1)->SetWidth(arg2);
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 resultobj = SWIG_Py_Void();
4909 return resultobj;
4910 fail:
4911 return NULL;
4912 }
4913
4914
4915 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4916 PyObject *resultobj = 0;
4917 wxSize *arg1 = (wxSize *) 0 ;
4918 int arg2 ;
4919 void *argp1 = 0 ;
4920 int res1 = 0 ;
4921 int val2 ;
4922 int ecode2 = 0 ;
4923 PyObject * obj0 = 0 ;
4924 PyObject * obj1 = 0 ;
4925 char * kwnames[] = {
4926 (char *) "self",(char *) "h", NULL
4927 };
4928
4929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4931 if (!SWIG_IsOK(res1)) {
4932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4933 }
4934 arg1 = reinterpret_cast< wxSize * >(argp1);
4935 ecode2 = SWIG_AsVal_int(obj1, &val2);
4936 if (!SWIG_IsOK(ecode2)) {
4937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4938 }
4939 arg2 = static_cast< int >(val2);
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 (arg1)->SetHeight(arg2);
4943 wxPyEndAllowThreads(__tstate);
4944 if (PyErr_Occurred()) SWIG_fail;
4945 }
4946 resultobj = SWIG_Py_Void();
4947 return resultobj;
4948 fail:
4949 return NULL;
4950 }
4951
4952
4953 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4954 PyObject *resultobj = 0;
4955 wxSize *arg1 = (wxSize *) 0 ;
4956 int result;
4957 void *argp1 = 0 ;
4958 int res1 = 0 ;
4959 PyObject *swig_obj[1] ;
4960
4961 if (!args) SWIG_fail;
4962 swig_obj[0] = args;
4963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (int)((wxSize const *)arg1)->GetWidth();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 resultobj = SWIG_From_int(static_cast< int >(result));
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4982 PyObject *resultobj = 0;
4983 wxSize *arg1 = (wxSize *) 0 ;
4984 int result;
4985 void *argp1 = 0 ;
4986 int res1 = 0 ;
4987 PyObject *swig_obj[1] ;
4988
4989 if (!args) SWIG_fail;
4990 swig_obj[0] = args;
4991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4992 if (!SWIG_IsOK(res1)) {
4993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4994 }
4995 arg1 = reinterpret_cast< wxSize * >(argp1);
4996 {
4997 PyThreadState* __tstate = wxPyBeginAllowThreads();
4998 result = (int)((wxSize const *)arg1)->GetHeight();
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 resultobj = SWIG_From_int(static_cast< int >(result));
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5010 PyObject *resultobj = 0;
5011 wxSize *arg1 = (wxSize *) 0 ;
5012 bool result;
5013 void *argp1 = 0 ;
5014 int res1 = 0 ;
5015 PyObject *swig_obj[1] ;
5016
5017 if (!args) SWIG_fail;
5018 swig_obj[0] = args;
5019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5022 }
5023 arg1 = reinterpret_cast< wxSize * >(argp1);
5024 {
5025 PyThreadState* __tstate = wxPyBeginAllowThreads();
5026 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5027 wxPyEndAllowThreads(__tstate);
5028 if (PyErr_Occurred()) SWIG_fail;
5029 }
5030 {
5031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5032 }
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 wxSize *arg2 = 0 ;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 wxSize temp2 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 char * kwnames[] = {
5049 (char *) "self",(char *) "size", NULL
5050 };
5051
5052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5054 if (!SWIG_IsOK(res1)) {
5055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5056 }
5057 arg1 = reinterpret_cast< wxSize * >(argp1);
5058 {
5059 arg2 = &temp2;
5060 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5061 }
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 (arg1)->SetDefaults((wxSize const &)*arg2);
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 resultobj = SWIG_Py_Void();
5069 return resultobj;
5070 fail:
5071 return NULL;
5072 }
5073
5074
5075 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5076 PyObject *resultobj = 0;
5077 wxSize *arg1 = (wxSize *) 0 ;
5078 PyObject *result = 0 ;
5079 void *argp1 = 0 ;
5080 int res1 = 0 ;
5081 PyObject *swig_obj[1] ;
5082
5083 if (!args) SWIG_fail;
5084 swig_obj[0] = args;
5085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5086 if (!SWIG_IsOK(res1)) {
5087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5088 }
5089 arg1 = reinterpret_cast< wxSize * >(argp1);
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (PyObject *)wxSize_Get(arg1);
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 resultobj = result;
5097 return resultobj;
5098 fail:
5099 return NULL;
5100 }
5101
5102
5103 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5104 PyObject *obj;
5105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5106 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5107 return SWIG_Py_Void();
5108 }
5109
5110 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5111 return SWIG_Python_InitShadowInstance(args);
5112 }
5113
5114 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5115 PyObject *resultobj = 0;
5116 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5117 double arg2 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 double val2 ;
5121 int ecode2 = 0 ;
5122 PyObject *swig_obj[2] ;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5128 }
5129 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5130 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5131 if (!SWIG_IsOK(ecode2)) {
5132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5133 }
5134 arg2 = static_cast< double >(val2);
5135 if (arg1) (arg1)->x = arg2;
5136
5137 resultobj = SWIG_Py_Void();
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *resultobj = 0;
5146 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5147 double result;
5148 void *argp1 = 0 ;
5149 int res1 = 0 ;
5150 PyObject *swig_obj[1] ;
5151
5152 if (!args) SWIG_fail;
5153 swig_obj[0] = args;
5154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5155 if (!SWIG_IsOK(res1)) {
5156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5157 }
5158 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5159 result = (double) ((arg1)->x);
5160 resultobj = SWIG_From_double(static_cast< double >(result));
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5168 PyObject *resultobj = 0;
5169 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5170 double arg2 ;
5171 void *argp1 = 0 ;
5172 int res1 = 0 ;
5173 double val2 ;
5174 int ecode2 = 0 ;
5175 PyObject *swig_obj[2] ;
5176
5177 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5181 }
5182 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5183 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5184 if (!SWIG_IsOK(ecode2)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5186 }
5187 arg2 = static_cast< double >(val2);
5188 if (arg1) (arg1)->y = arg2;
5189
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 PyObject *resultobj = 0;
5199 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5200 double result;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 PyObject *swig_obj[1] ;
5204
5205 if (!args) SWIG_fail;
5206 swig_obj[0] = args;
5207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5210 }
5211 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5212 result = (double) ((arg1)->y);
5213 resultobj = SWIG_From_double(static_cast< double >(result));
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 double arg1 = (double) 0.0 ;
5223 double arg2 = (double) 0.0 ;
5224 wxRealPoint *result = 0 ;
5225 double val1 ;
5226 int ecode1 = 0 ;
5227 double val2 ;
5228 int ecode2 = 0 ;
5229 PyObject * obj0 = 0 ;
5230 PyObject * obj1 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "x",(char *) "y", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5236 if (obj0) {
5237 ecode1 = SWIG_AsVal_double(obj0, &val1);
5238 if (!SWIG_IsOK(ecode1)) {
5239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5240 }
5241 arg1 = static_cast< double >(val1);
5242 }
5243 if (obj1) {
5244 ecode2 = SWIG_AsVal_double(obj1, &val2);
5245 if (!SWIG_IsOK(ecode2)) {
5246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5247 }
5248 arg2 = static_cast< double >(val2);
5249 }
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 PyObject *swig_obj[1] ;
5269
5270 if (!args) SWIG_fail;
5271 swig_obj[0] = args;
5272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5273 if (!SWIG_IsOK(res1)) {
5274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5275 }
5276 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5277 {
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 delete arg1;
5280
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5294 PyObject *arg2 = (PyObject *) 0 ;
5295 bool result;
5296 void *argp1 = 0 ;
5297 int res1 = 0 ;
5298 PyObject * obj0 = 0 ;
5299 PyObject * obj1 = 0 ;
5300 char * kwnames[] = {
5301 (char *) "self",(char *) "other", NULL
5302 };
5303
5304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5308 }
5309 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5310 arg2 = obj1;
5311 {
5312 result = (bool)wxRealPoint___eq__(arg1,arg2);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 {
5316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5317 }
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj = 0;
5326 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5327 PyObject *arg2 = (PyObject *) 0 ;
5328 bool result;
5329 void *argp1 = 0 ;
5330 int res1 = 0 ;
5331 PyObject * obj0 = 0 ;
5332 PyObject * obj1 = 0 ;
5333 char * kwnames[] = {
5334 (char *) "self",(char *) "other", NULL
5335 };
5336
5337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5339 if (!SWIG_IsOK(res1)) {
5340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5341 }
5342 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5343 arg2 = obj1;
5344 {
5345 result = (bool)wxRealPoint___ne__(arg1,arg2);
5346 if (PyErr_Occurred()) SWIG_fail;
5347 }
5348 {
5349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5350 }
5351 return resultobj;
5352 fail:
5353 return NULL;
5354 }
5355
5356
5357 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5358 PyObject *resultobj = 0;
5359 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5360 wxRealPoint *arg2 = 0 ;
5361 wxRealPoint result;
5362 void *argp1 = 0 ;
5363 int res1 = 0 ;
5364 wxRealPoint temp2 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char * kwnames[] = {
5368 (char *) "self",(char *) "pt", NULL
5369 };
5370
5371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 {
5378 arg2 = &temp2;
5379 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5380 }
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj = 0;
5396 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5397 wxRealPoint *arg2 = 0 ;
5398 wxRealPoint result;
5399 void *argp1 = 0 ;
5400 int res1 = 0 ;
5401 wxRealPoint temp2 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "pt", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 {
5415 arg2 = &temp2;
5416 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5417 }
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5432 PyObject *resultobj = 0;
5433 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5434 double arg2 ;
5435 double arg3 ;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 double val2 ;
5439 int ecode2 = 0 ;
5440 double val3 ;
5441 int ecode3 = 0 ;
5442 PyObject * obj0 = 0 ;
5443 PyObject * obj1 = 0 ;
5444 PyObject * obj2 = 0 ;
5445 char * kwnames[] = {
5446 (char *) "self",(char *) "x",(char *) "y", NULL
5447 };
5448
5449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5451 if (!SWIG_IsOK(res1)) {
5452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5453 }
5454 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5455 ecode2 = SWIG_AsVal_double(obj1, &val2);
5456 if (!SWIG_IsOK(ecode2)) {
5457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5458 }
5459 arg2 = static_cast< double >(val2);
5460 ecode3 = SWIG_AsVal_double(obj2, &val3);
5461 if (!SWIG_IsOK(ecode3)) {
5462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5463 }
5464 arg3 = static_cast< double >(val3);
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 wxRealPoint_Set(arg1,arg2,arg3);
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 resultobj = SWIG_Py_Void();
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *resultobj = 0;
5480 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5481 PyObject *result = 0 ;
5482 void *argp1 = 0 ;
5483 int res1 = 0 ;
5484 PyObject *swig_obj[1] ;
5485
5486 if (!args) SWIG_fail;
5487 swig_obj[0] = args;
5488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (PyObject *)wxRealPoint_Get(arg1);
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = result;
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *obj;
5508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5509 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5510 return SWIG_Py_Void();
5511 }
5512
5513 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5514 return SWIG_Python_InitShadowInstance(args);
5515 }
5516
5517 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518 PyObject *resultobj = 0;
5519 wxPoint *arg1 = (wxPoint *) 0 ;
5520 int arg2 ;
5521 void *argp1 = 0 ;
5522 int res1 = 0 ;
5523 int val2 ;
5524 int ecode2 = 0 ;
5525 PyObject *swig_obj[2] ;
5526
5527 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5529 if (!SWIG_IsOK(res1)) {
5530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5531 }
5532 arg1 = reinterpret_cast< wxPoint * >(argp1);
5533 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5534 if (!SWIG_IsOK(ecode2)) {
5535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5536 }
5537 arg2 = static_cast< int >(val2);
5538 if (arg1) (arg1)->x = arg2;
5539
5540 resultobj = SWIG_Py_Void();
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5548 PyObject *resultobj = 0;
5549 wxPoint *arg1 = (wxPoint *) 0 ;
5550 int result;
5551 void *argp1 = 0 ;
5552 int res1 = 0 ;
5553 PyObject *swig_obj[1] ;
5554
5555 if (!args) SWIG_fail;
5556 swig_obj[0] = args;
5557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5558 if (!SWIG_IsOK(res1)) {
5559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5560 }
5561 arg1 = reinterpret_cast< wxPoint * >(argp1);
5562 result = (int) ((arg1)->x);
5563 resultobj = SWIG_From_int(static_cast< int >(result));
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxPoint *arg1 = (wxPoint *) 0 ;
5573 int arg2 ;
5574 void *argp1 = 0 ;
5575 int res1 = 0 ;
5576 int val2 ;
5577 int ecode2 = 0 ;
5578 PyObject *swig_obj[2] ;
5579
5580 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5582 if (!SWIG_IsOK(res1)) {
5583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5584 }
5585 arg1 = reinterpret_cast< wxPoint * >(argp1);
5586 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5587 if (!SWIG_IsOK(ecode2)) {
5588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5589 }
5590 arg2 = static_cast< int >(val2);
5591 if (arg1) (arg1)->y = arg2;
5592
5593 resultobj = SWIG_Py_Void();
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602 wxPoint *arg1 = (wxPoint *) 0 ;
5603 int result;
5604 void *argp1 = 0 ;
5605 int res1 = 0 ;
5606 PyObject *swig_obj[1] ;
5607
5608 if (!args) SWIG_fail;
5609 swig_obj[0] = args;
5610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5613 }
5614 arg1 = reinterpret_cast< wxPoint * >(argp1);
5615 result = (int) ((arg1)->y);
5616 resultobj = SWIG_From_int(static_cast< int >(result));
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 int arg1 = (int) 0 ;
5626 int arg2 = (int) 0 ;
5627 wxPoint *result = 0 ;
5628 int val1 ;
5629 int ecode1 = 0 ;
5630 int val2 ;
5631 int ecode2 = 0 ;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 char * kwnames[] = {
5635 (char *) "x",(char *) "y", NULL
5636 };
5637
5638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5639 if (obj0) {
5640 ecode1 = SWIG_AsVal_int(obj0, &val1);
5641 if (!SWIG_IsOK(ecode1)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5643 }
5644 arg1 = static_cast< int >(val1);
5645 }
5646 if (obj1) {
5647 ecode2 = SWIG_AsVal_int(obj1, &val2);
5648 if (!SWIG_IsOK(ecode2)) {
5649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5650 }
5651 arg2 = static_cast< int >(val2);
5652 }
5653 {
5654 PyThreadState* __tstate = wxPyBeginAllowThreads();
5655 result = (wxPoint *)new wxPoint(arg1,arg2);
5656 wxPyEndAllowThreads(__tstate);
5657 if (PyErr_Occurred()) SWIG_fail;
5658 }
5659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5660 return resultobj;
5661 fail:
5662 return NULL;
5663 }
5664
5665
5666 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5667 PyObject *resultobj = 0;
5668 wxPoint *arg1 = (wxPoint *) 0 ;
5669 void *argp1 = 0 ;
5670 int res1 = 0 ;
5671 PyObject *swig_obj[1] ;
5672
5673 if (!args) SWIG_fail;
5674 swig_obj[0] = args;
5675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5676 if (!SWIG_IsOK(res1)) {
5677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5678 }
5679 arg1 = reinterpret_cast< wxPoint * >(argp1);
5680 {
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 delete arg1;
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 resultobj = SWIG_Py_Void();
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 wxPoint *arg1 = (wxPoint *) 0 ;
5697 PyObject *arg2 = (PyObject *) 0 ;
5698 bool result;
5699 void *argp1 = 0 ;
5700 int res1 = 0 ;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 char * kwnames[] = {
5704 (char *) "self",(char *) "other", NULL
5705 };
5706
5707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5709 if (!SWIG_IsOK(res1)) {
5710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5711 }
5712 arg1 = reinterpret_cast< wxPoint * >(argp1);
5713 arg2 = obj1;
5714 {
5715 result = (bool)wxPoint___eq__(arg1,arg2);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 {
5719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5720 }
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj = 0;
5729 wxPoint *arg1 = (wxPoint *) 0 ;
5730 PyObject *arg2 = (PyObject *) 0 ;
5731 bool result;
5732 void *argp1 = 0 ;
5733 int res1 = 0 ;
5734 PyObject * obj0 = 0 ;
5735 PyObject * obj1 = 0 ;
5736 char * kwnames[] = {
5737 (char *) "self",(char *) "other", NULL
5738 };
5739
5740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5742 if (!SWIG_IsOK(res1)) {
5743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5744 }
5745 arg1 = reinterpret_cast< wxPoint * >(argp1);
5746 arg2 = obj1;
5747 {
5748 result = (bool)wxPoint___ne__(arg1,arg2);
5749 if (PyErr_Occurred()) SWIG_fail;
5750 }
5751 {
5752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5753 }
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj = 0;
5762 wxPoint *arg1 = (wxPoint *) 0 ;
5763 wxPoint *arg2 = 0 ;
5764 wxPoint result;
5765 void *argp1 = 0 ;
5766 int res1 = 0 ;
5767 wxPoint temp2 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "self",(char *) "pt", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 {
5781 arg2 = &temp2;
5782 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5783 }
5784 {
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 result = (arg1)->operator +((wxPoint const &)*arg2);
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5791 return resultobj;
5792 fail:
5793 return NULL;
5794 }
5795
5796
5797 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5798 PyObject *resultobj = 0;
5799 wxPoint *arg1 = (wxPoint *) 0 ;
5800 wxPoint *arg2 = 0 ;
5801 wxPoint result;
5802 void *argp1 = 0 ;
5803 int res1 = 0 ;
5804 wxPoint temp2 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "pt", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 {
5818 arg2 = &temp2;
5819 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5820 }
5821 {
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 result = (arg1)->operator -((wxPoint const &)*arg2);
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
5834 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj = 0;
5836 wxPoint *arg1 = (wxPoint *) 0 ;
5837 wxPoint *arg2 = 0 ;
5838 wxPoint *result = 0 ;
5839 void *argp1 = 0 ;
5840 int res1 = 0 ;
5841 wxPoint temp2 ;
5842 PyObject * obj0 = 0 ;
5843 PyObject * obj1 = 0 ;
5844 char * kwnames[] = {
5845 (char *) "self",(char *) "pt", NULL
5846 };
5847
5848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5850 if (!SWIG_IsOK(res1)) {
5851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5852 }
5853 arg1 = reinterpret_cast< wxPoint * >(argp1);
5854 {
5855 arg2 = &temp2;
5856 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5857 }
5858 {
5859 PyThreadState* __tstate = wxPyBeginAllowThreads();
5860 {
5861 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5862 result = (wxPoint *) &_result_ref;
5863 }
5864 wxPyEndAllowThreads(__tstate);
5865 if (PyErr_Occurred()) SWIG_fail;
5866 }
5867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxPoint *arg1 = (wxPoint *) 0 ;
5877 wxPoint *arg2 = 0 ;
5878 wxPoint *result = 0 ;
5879 void *argp1 = 0 ;
5880 int res1 = 0 ;
5881 wxPoint temp2 ;
5882 PyObject * obj0 = 0 ;
5883 PyObject * obj1 = 0 ;
5884 char * kwnames[] = {
5885 (char *) "self",(char *) "pt", NULL
5886 };
5887
5888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 {
5895 arg2 = &temp2;
5896 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5897 }
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 {
5901 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5902 result = (wxPoint *) &_result_ref;
5903 }
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5908 return resultobj;
5909 fail:
5910 return NULL;
5911 }
5912
5913
5914 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5915 PyObject *resultobj = 0;
5916 wxPoint *arg1 = (wxPoint *) 0 ;
5917 long arg2 ;
5918 long arg3 ;
5919 void *argp1 = 0 ;
5920 int res1 = 0 ;
5921 long val2 ;
5922 int ecode2 = 0 ;
5923 long val3 ;
5924 int ecode3 = 0 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 PyObject * obj2 = 0 ;
5928 char * kwnames[] = {
5929 (char *) "self",(char *) "x",(char *) "y", NULL
5930 };
5931
5932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5934 if (!SWIG_IsOK(res1)) {
5935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5936 }
5937 arg1 = reinterpret_cast< wxPoint * >(argp1);
5938 ecode2 = SWIG_AsVal_long(obj1, &val2);
5939 if (!SWIG_IsOK(ecode2)) {
5940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5941 }
5942 arg2 = static_cast< long >(val2);
5943 ecode3 = SWIG_AsVal_long(obj2, &val3);
5944 if (!SWIG_IsOK(ecode3)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5946 }
5947 arg3 = static_cast< long >(val3);
5948 {
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 wxPoint_Set(arg1,arg2,arg3);
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_Py_Void();
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 PyObject *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 PyObject *swig_obj[1] ;
5968
5969 if (!args) SWIG_fail;
5970 swig_obj[0] = args;
5971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5972 if (!SWIG_IsOK(res1)) {
5973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5974 }
5975 arg1 = reinterpret_cast< wxPoint * >(argp1);
5976 {
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 result = (PyObject *)wxPoint_Get(arg1);
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 resultobj = result;
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 PyObject *obj;
5991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5992 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5993 return SWIG_Py_Void();
5994 }
5995
5996 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5997 return SWIG_Python_InitShadowInstance(args);
5998 }
5999
6000 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 int arg1 = (int) 0 ;
6003 int arg2 = (int) 0 ;
6004 int arg3 = (int) 0 ;
6005 int arg4 = (int) 0 ;
6006 wxRect *result = 0 ;
6007 int val1 ;
6008 int ecode1 = 0 ;
6009 int val2 ;
6010 int ecode2 = 0 ;
6011 int val3 ;
6012 int ecode3 = 0 ;
6013 int val4 ;
6014 int ecode4 = 0 ;
6015 PyObject * obj0 = 0 ;
6016 PyObject * obj1 = 0 ;
6017 PyObject * obj2 = 0 ;
6018 PyObject * obj3 = 0 ;
6019 char * kwnames[] = {
6020 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6021 };
6022
6023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6024 if (obj0) {
6025 ecode1 = SWIG_AsVal_int(obj0, &val1);
6026 if (!SWIG_IsOK(ecode1)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6028 }
6029 arg1 = static_cast< int >(val1);
6030 }
6031 if (obj1) {
6032 ecode2 = SWIG_AsVal_int(obj1, &val2);
6033 if (!SWIG_IsOK(ecode2)) {
6034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6035 }
6036 arg2 = static_cast< int >(val2);
6037 }
6038 if (obj2) {
6039 ecode3 = SWIG_AsVal_int(obj2, &val3);
6040 if (!SWIG_IsOK(ecode3)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6042 }
6043 arg3 = static_cast< int >(val3);
6044 }
6045 if (obj3) {
6046 ecode4 = SWIG_AsVal_int(obj3, &val4);
6047 if (!SWIG_IsOK(ecode4)) {
6048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6049 }
6050 arg4 = static_cast< int >(val4);
6051 }
6052 {
6053 PyThreadState* __tstate = wxPyBeginAllowThreads();
6054 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6055 wxPyEndAllowThreads(__tstate);
6056 if (PyErr_Occurred()) SWIG_fail;
6057 }
6058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj = 0;
6067 wxPoint *arg1 = 0 ;
6068 wxPoint *arg2 = 0 ;
6069 wxRect *result = 0 ;
6070 wxPoint temp1 ;
6071 wxPoint temp2 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 char * kwnames[] = {
6075 (char *) "topLeft",(char *) "bottomRight", NULL
6076 };
6077
6078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6079 {
6080 arg1 = &temp1;
6081 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6082 }
6083 {
6084 arg2 = &temp2;
6085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6090 wxPyEndAllowThreads(__tstate);
6091 if (PyErr_Occurred()) SWIG_fail;
6092 }
6093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj = 0;
6102 wxPoint *arg1 = 0 ;
6103 wxSize *arg2 = 0 ;
6104 wxRect *result = 0 ;
6105 wxPoint temp1 ;
6106 wxSize temp2 ;
6107 PyObject * obj0 = 0 ;
6108 PyObject * obj1 = 0 ;
6109 char * kwnames[] = {
6110 (char *) "pos",(char *) "size", NULL
6111 };
6112
6113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6114 {
6115 arg1 = &temp1;
6116 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6117 }
6118 {
6119 arg2 = &temp2;
6120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6121 }
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj = 0;
6137 wxSize *arg1 = 0 ;
6138 wxRect *result = 0 ;
6139 wxSize temp1 ;
6140 PyObject * obj0 = 0 ;
6141 char * kwnames[] = {
6142 (char *) "size", NULL
6143 };
6144
6145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6146 {
6147 arg1 = &temp1;
6148 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6149 }
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6153 wxPyEndAllowThreads(__tstate);
6154 if (PyErr_Occurred()) SWIG_fail;
6155 }
6156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6157 return resultobj;
6158 fail:
6159 return NULL;
6160 }
6161
6162
6163 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6164 PyObject *resultobj = 0;
6165 wxRect *arg1 = (wxRect *) 0 ;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 PyObject *swig_obj[1] ;
6169
6170 if (!args) SWIG_fail;
6171 swig_obj[0] = args;
6172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6173 if (!SWIG_IsOK(res1)) {
6174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6175 }
6176 arg1 = reinterpret_cast< wxRect * >(argp1);
6177 {
6178 PyThreadState* __tstate = wxPyBeginAllowThreads();
6179 delete arg1;
6180
6181 wxPyEndAllowThreads(__tstate);
6182 if (PyErr_Occurred()) SWIG_fail;
6183 }
6184 resultobj = SWIG_Py_Void();
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6192 PyObject *resultobj = 0;
6193 wxRect *arg1 = (wxRect *) 0 ;
6194 int result;
6195 void *argp1 = 0 ;
6196 int res1 = 0 ;
6197 PyObject *swig_obj[1] ;
6198
6199 if (!args) SWIG_fail;
6200 swig_obj[0] = args;
6201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6202 if (!SWIG_IsOK(res1)) {
6203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6204 }
6205 arg1 = reinterpret_cast< wxRect * >(argp1);
6206 {
6207 PyThreadState* __tstate = wxPyBeginAllowThreads();
6208 result = (int)((wxRect const *)arg1)->GetX();
6209 wxPyEndAllowThreads(__tstate);
6210 if (PyErr_Occurred()) SWIG_fail;
6211 }
6212 resultobj = SWIG_From_int(static_cast< int >(result));
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj = 0;
6221 wxRect *arg1 = (wxRect *) 0 ;
6222 int arg2 ;
6223 void *argp1 = 0 ;
6224 int res1 = 0 ;
6225 int val2 ;
6226 int ecode2 = 0 ;
6227 PyObject * obj0 = 0 ;
6228 PyObject * obj1 = 0 ;
6229 char * kwnames[] = {
6230 (char *) "self",(char *) "x", NULL
6231 };
6232
6233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6235 if (!SWIG_IsOK(res1)) {
6236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6237 }
6238 arg1 = reinterpret_cast< wxRect * >(argp1);
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 (arg1)->SetX(arg2);
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_Py_Void();
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258 PyObject *resultobj = 0;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int result;
6261 void *argp1 = 0 ;
6262 int res1 = 0 ;
6263 PyObject *swig_obj[1] ;
6264
6265 if (!args) SWIG_fail;
6266 swig_obj[0] = args;
6267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6270 }
6271 arg1 = reinterpret_cast< wxRect * >(argp1);
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (int)(arg1)->GetY();
6275 wxPyEndAllowThreads(__tstate);
6276 if (PyErr_Occurred()) SWIG_fail;
6277 }
6278 resultobj = SWIG_From_int(static_cast< int >(result));
6279 return resultobj;
6280 fail:
6281 return NULL;
6282 }
6283
6284
6285 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6286 PyObject *resultobj = 0;
6287 wxRect *arg1 = (wxRect *) 0 ;
6288 int arg2 ;
6289 void *argp1 = 0 ;
6290 int res1 = 0 ;
6291 int val2 ;
6292 int ecode2 = 0 ;
6293 PyObject * obj0 = 0 ;
6294 PyObject * obj1 = 0 ;
6295 char * kwnames[] = {
6296 (char *) "self",(char *) "y", NULL
6297 };
6298
6299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6301 if (!SWIG_IsOK(res1)) {
6302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6303 }
6304 arg1 = reinterpret_cast< wxRect * >(argp1);
6305 ecode2 = SWIG_AsVal_int(obj1, &val2);
6306 if (!SWIG_IsOK(ecode2)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6308 }
6309 arg2 = static_cast< int >(val2);
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 (arg1)->SetY(arg2);
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 resultobj = SWIG_Py_Void();
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6324 PyObject *resultobj = 0;
6325 wxRect *arg1 = (wxRect *) 0 ;
6326 int result;
6327 void *argp1 = 0 ;
6328 int res1 = 0 ;
6329 PyObject *swig_obj[1] ;
6330
6331 if (!args) SWIG_fail;
6332 swig_obj[0] = args;
6333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6334 if (!SWIG_IsOK(res1)) {
6335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6336 }
6337 arg1 = reinterpret_cast< wxRect * >(argp1);
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 result = (int)((wxRect const *)arg1)->GetWidth();
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 resultobj = SWIG_From_int(static_cast< int >(result));
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = 0;
6353 wxRect *arg1 = (wxRect *) 0 ;
6354 int arg2 ;
6355 void *argp1 = 0 ;
6356 int res1 = 0 ;
6357 int val2 ;
6358 int ecode2 = 0 ;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "self",(char *) "w", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 ecode2 = SWIG_AsVal_int(obj1, &val2);
6372 if (!SWIG_IsOK(ecode2)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6374 }
6375 arg2 = static_cast< int >(val2);
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 (arg1)->SetWidth(arg2);
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = SWIG_Py_Void();
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6390 PyObject *resultobj = 0;
6391 wxRect *arg1 = (wxRect *) 0 ;
6392 int result;
6393 void *argp1 = 0 ;
6394 int res1 = 0 ;
6395 PyObject *swig_obj[1] ;
6396
6397 if (!args) SWIG_fail;
6398 swig_obj[0] = args;
6399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6400 if (!SWIG_IsOK(res1)) {
6401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6402 }
6403 arg1 = reinterpret_cast< wxRect * >(argp1);
6404 {
6405 PyThreadState* __tstate = wxPyBeginAllowThreads();
6406 result = (int)((wxRect const *)arg1)->GetHeight();
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_From_int(static_cast< int >(result));
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 int arg2 ;
6421 void *argp1 = 0 ;
6422 int res1 = 0 ;
6423 int val2 ;
6424 int ecode2 = 0 ;
6425 PyObject * obj0 = 0 ;
6426 PyObject * obj1 = 0 ;
6427 char * kwnames[] = {
6428 (char *) "self",(char *) "h", NULL
6429 };
6430
6431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6433 if (!SWIG_IsOK(res1)) {
6434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6435 }
6436 arg1 = reinterpret_cast< wxRect * >(argp1);
6437 ecode2 = SWIG_AsVal_int(obj1, &val2);
6438 if (!SWIG_IsOK(ecode2)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6440 }
6441 arg2 = static_cast< int >(val2);
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->SetHeight(arg2);
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_Py_Void();
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456 PyObject *resultobj = 0;
6457 wxRect *arg1 = (wxRect *) 0 ;
6458 wxPoint result;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 PyObject *swig_obj[1] ;
6462
6463 if (!args) SWIG_fail;
6464 swig_obj[0] = args;
6465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6468 }
6469 arg1 = reinterpret_cast< wxRect * >(argp1);
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = ((wxRect const *)arg1)->GetPosition();
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj = 0;
6485 wxRect *arg1 = (wxRect *) 0 ;
6486 wxPoint *arg2 = 0 ;
6487 void *argp1 = 0 ;
6488 int res1 = 0 ;
6489 wxPoint temp2 ;
6490 PyObject * obj0 = 0 ;
6491 PyObject * obj1 = 0 ;
6492 char * kwnames[] = {
6493 (char *) "self",(char *) "p", NULL
6494 };
6495
6496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6498 if (!SWIG_IsOK(res1)) {
6499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6500 }
6501 arg1 = reinterpret_cast< wxRect * >(argp1);
6502 {
6503 arg2 = &temp2;
6504 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6505 }
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 (arg1)->SetPosition((wxPoint const &)*arg2);
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_Py_Void();
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6520 PyObject *resultobj = 0;
6521 wxRect *arg1 = (wxRect *) 0 ;
6522 wxSize result;
6523 void *argp1 = 0 ;
6524 int res1 = 0 ;
6525 PyObject *swig_obj[1] ;
6526
6527 if (!args) SWIG_fail;
6528 swig_obj[0] = args;
6529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6530 if (!SWIG_IsOK(res1)) {
6531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6532 }
6533 arg1 = reinterpret_cast< wxRect * >(argp1);
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = ((wxRect const *)arg1)->GetSize();
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxRect *arg1 = (wxRect *) 0 ;
6550 wxSize *arg2 = 0 ;
6551 void *argp1 = 0 ;
6552 int res1 = 0 ;
6553 wxSize temp2 ;
6554 PyObject * obj0 = 0 ;
6555 PyObject * obj1 = 0 ;
6556 char * kwnames[] = {
6557 (char *) "self",(char *) "s", NULL
6558 };
6559
6560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6562 if (!SWIG_IsOK(res1)) {
6563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6564 }
6565 arg1 = reinterpret_cast< wxRect * >(argp1);
6566 {
6567 arg2 = &temp2;
6568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6569 }
6570 {
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 (arg1)->SetSize((wxSize const &)*arg2);
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_Py_Void();
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6584 PyObject *resultobj = 0;
6585 wxRect *arg1 = (wxRect *) 0 ;
6586 bool result;
6587 void *argp1 = 0 ;
6588 int res1 = 0 ;
6589 PyObject *swig_obj[1] ;
6590
6591 if (!args) SWIG_fail;
6592 swig_obj[0] = args;
6593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6594 if (!SWIG_IsOK(res1)) {
6595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6596 }
6597 arg1 = reinterpret_cast< wxRect * >(argp1);
6598 {
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 result = (bool)((wxRect const *)arg1)->IsEmpty();
6601 wxPyEndAllowThreads(__tstate);
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 {
6605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6606 }
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614 PyObject *resultobj = 0;
6615 wxRect *arg1 = (wxRect *) 0 ;
6616 wxPoint result;
6617 void *argp1 = 0 ;
6618 int res1 = 0 ;
6619 PyObject *swig_obj[1] ;
6620
6621 if (!args) SWIG_fail;
6622 swig_obj[0] = args;
6623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6624 if (!SWIG_IsOK(res1)) {
6625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6626 }
6627 arg1 = reinterpret_cast< wxRect * >(argp1);
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 result = ((wxRect const *)arg1)->GetTopLeft();
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj = 0;
6643 wxRect *arg1 = (wxRect *) 0 ;
6644 wxPoint *arg2 = 0 ;
6645 void *argp1 = 0 ;
6646 int res1 = 0 ;
6647 wxPoint temp2 ;
6648 PyObject * obj0 = 0 ;
6649 PyObject * obj1 = 0 ;
6650 char * kwnames[] = {
6651 (char *) "self",(char *) "p", NULL
6652 };
6653
6654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6656 if (!SWIG_IsOK(res1)) {
6657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6658 }
6659 arg1 = reinterpret_cast< wxRect * >(argp1);
6660 {
6661 arg2 = &temp2;
6662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 resultobj = SWIG_Py_Void();
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6678 PyObject *resultobj = 0;
6679 wxRect *arg1 = (wxRect *) 0 ;
6680 wxPoint result;
6681 void *argp1 = 0 ;
6682 int res1 = 0 ;
6683 PyObject *swig_obj[1] ;
6684
6685 if (!args) SWIG_fail;
6686 swig_obj[0] = args;
6687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6688 if (!SWIG_IsOK(res1)) {
6689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6690 }
6691 arg1 = reinterpret_cast< wxRect * >(argp1);
6692 {
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 result = ((wxRect const *)arg1)->GetBottomRight();
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj = 0;
6707 wxRect *arg1 = (wxRect *) 0 ;
6708 wxPoint *arg2 = 0 ;
6709 void *argp1 = 0 ;
6710 int res1 = 0 ;
6711 wxPoint temp2 ;
6712 PyObject * obj0 = 0 ;
6713 PyObject * obj1 = 0 ;
6714 char * kwnames[] = {
6715 (char *) "self",(char *) "p", NULL
6716 };
6717
6718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6720 if (!SWIG_IsOK(res1)) {
6721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6722 }
6723 arg1 = reinterpret_cast< wxRect * >(argp1);
6724 {
6725 arg2 = &temp2;
6726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6727 }
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_GetLeft(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_GetLeft" "', 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)->GetLeft();
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_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 int result;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 PyObject *swig_obj[1] ;
6776
6777 if (!args) SWIG_fail;
6778 swig_obj[0] = args;
6779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6780 if (!SWIG_IsOK(res1)) {
6781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6782 }
6783 arg1 = reinterpret_cast< wxRect * >(argp1);
6784 {
6785 PyThreadState* __tstate = wxPyBeginAllowThreads();
6786 result = (int)((wxRect const *)arg1)->GetTop();
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 resultobj = SWIG_From_int(static_cast< int >(result));
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6798 PyObject *resultobj = 0;
6799 wxRect *arg1 = (wxRect *) 0 ;
6800 int result;
6801 void *argp1 = 0 ;
6802 int res1 = 0 ;
6803 PyObject *swig_obj[1] ;
6804
6805 if (!args) SWIG_fail;
6806 swig_obj[0] = args;
6807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6810 }
6811 arg1 = reinterpret_cast< wxRect * >(argp1);
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)((wxRect const *)arg1)->GetBottom();
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 resultobj = SWIG_From_int(static_cast< int >(result));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 PyObject *resultobj = 0;
6827 wxRect *arg1 = (wxRect *) 0 ;
6828 int result;
6829 void *argp1 = 0 ;
6830 int res1 = 0 ;
6831 PyObject *swig_obj[1] ;
6832
6833 if (!args) SWIG_fail;
6834 swig_obj[0] = args;
6835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6836 if (!SWIG_IsOK(res1)) {
6837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6838 }
6839 arg1 = reinterpret_cast< wxRect * >(argp1);
6840 {
6841 PyThreadState* __tstate = wxPyBeginAllowThreads();
6842 result = (int)((wxRect const *)arg1)->GetRight();
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_From_int(static_cast< int >(result));
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj = 0;
6855 wxRect *arg1 = (wxRect *) 0 ;
6856 int arg2 ;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 int val2 ;
6860 int ecode2 = 0 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char * kwnames[] = {
6864 (char *) "self",(char *) "left", NULL
6865 };
6866
6867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 ecode2 = SWIG_AsVal_int(obj1, &val2);
6874 if (!SWIG_IsOK(ecode2)) {
6875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6876 }
6877 arg2 = static_cast< int >(val2);
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 (arg1)->SetLeft(arg2);
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_Py_Void();
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 int arg2 ;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 int val2 ;
6898 int ecode2 = 0 ;
6899 PyObject * obj0 = 0 ;
6900 PyObject * obj1 = 0 ;
6901 char * kwnames[] = {
6902 (char *) "self",(char *) "right", NULL
6903 };
6904
6905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6907 if (!SWIG_IsOK(res1)) {
6908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6909 }
6910 arg1 = reinterpret_cast< wxRect * >(argp1);
6911 ecode2 = SWIG_AsVal_int(obj1, &val2);
6912 if (!SWIG_IsOK(ecode2)) {
6913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6914 }
6915 arg2 = static_cast< int >(val2);
6916 {
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 (arg1)->SetRight(arg2);
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_Py_Void();
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxRect *arg1 = (wxRect *) 0 ;
6932 int arg2 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 int val2 ;
6936 int ecode2 = 0 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "top", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 ecode2 = SWIG_AsVal_int(obj1, &val2);
6950 if (!SWIG_IsOK(ecode2)) {
6951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6952 }
6953 arg2 = static_cast< int >(val2);
6954 {
6955 PyThreadState* __tstate = wxPyBeginAllowThreads();
6956 (arg1)->SetTop(arg2);
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_Py_Void();
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj = 0;
6969 wxRect *arg1 = (wxRect *) 0 ;
6970 int arg2 ;
6971 void *argp1 = 0 ;
6972 int res1 = 0 ;
6973 int val2 ;
6974 int ecode2 = 0 ;
6975 PyObject * obj0 = 0 ;
6976 PyObject * obj1 = 0 ;
6977 char * kwnames[] = {
6978 (char *) "self",(char *) "bottom", NULL
6979 };
6980
6981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6985 }
6986 arg1 = reinterpret_cast< wxRect * >(argp1);
6987 ecode2 = SWIG_AsVal_int(obj1, &val2);
6988 if (!SWIG_IsOK(ecode2)) {
6989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6990 }
6991 arg2 = static_cast< int >(val2);
6992 {
6993 PyThreadState* __tstate = wxPyBeginAllowThreads();
6994 (arg1)->SetBottom(arg2);
6995 wxPyEndAllowThreads(__tstate);
6996 if (PyErr_Occurred()) SWIG_fail;
6997 }
6998 resultobj = SWIG_Py_Void();
6999 return resultobj;
7000 fail:
7001 return NULL;
7002 }
7003
7004
7005 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7006 PyObject *resultobj = 0;
7007 wxRect *arg1 = (wxRect *) 0 ;
7008 int arg2 ;
7009 int arg3 ;
7010 wxRect *result = 0 ;
7011 void *argp1 = 0 ;
7012 int res1 = 0 ;
7013 int val2 ;
7014 int ecode2 = 0 ;
7015 int val3 ;
7016 int ecode3 = 0 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 PyObject * obj2 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "self",(char *) "dx",(char *) "dy", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7028 }
7029 arg1 = reinterpret_cast< wxRect * >(argp1);
7030 ecode2 = SWIG_AsVal_int(obj1, &val2);
7031 if (!SWIG_IsOK(ecode2)) {
7032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7033 }
7034 arg2 = static_cast< int >(val2);
7035 ecode3 = SWIG_AsVal_int(obj2, &val3);
7036 if (!SWIG_IsOK(ecode3)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7038 }
7039 arg3 = static_cast< int >(val3);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 {
7043 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7044 result = (wxRect *) &_result_ref;
7045 }
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj = 0;
7058 wxRect *arg1 = (wxRect *) 0 ;
7059 int arg2 ;
7060 int arg3 ;
7061 wxRect *result = 0 ;
7062 void *argp1 = 0 ;
7063 int res1 = 0 ;
7064 int val2 ;
7065 int ecode2 = 0 ;
7066 int val3 ;
7067 int ecode3 = 0 ;
7068 PyObject * obj0 = 0 ;
7069 PyObject * obj1 = 0 ;
7070 PyObject * obj2 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "self",(char *) "dx",(char *) "dy", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7079 }
7080 arg1 = reinterpret_cast< wxRect * >(argp1);
7081 ecode2 = SWIG_AsVal_int(obj1, &val2);
7082 if (!SWIG_IsOK(ecode2)) {
7083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7084 }
7085 arg2 = static_cast< int >(val2);
7086 ecode3 = SWIG_AsVal_int(obj2, &val3);
7087 if (!SWIG_IsOK(ecode3)) {
7088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7089 }
7090 arg3 = static_cast< int >(val3);
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 {
7094 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7095 result = (wxRect *) &_result_ref;
7096 }
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj = 0;
7109 wxRect *arg1 = (wxRect *) 0 ;
7110 int arg2 ;
7111 int arg3 ;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 int val2 ;
7115 int ecode2 = 0 ;
7116 int val3 ;
7117 int ecode3 = 0 ;
7118 PyObject * obj0 = 0 ;
7119 PyObject * obj1 = 0 ;
7120 PyObject * obj2 = 0 ;
7121 char * kwnames[] = {
7122 (char *) "self",(char *) "dx",(char *) "dy", NULL
7123 };
7124
7125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7127 if (!SWIG_IsOK(res1)) {
7128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7129 }
7130 arg1 = reinterpret_cast< wxRect * >(argp1);
7131 ecode2 = SWIG_AsVal_int(obj1, &val2);
7132 if (!SWIG_IsOK(ecode2)) {
7133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7134 }
7135 arg2 = static_cast< int >(val2);
7136 ecode3 = SWIG_AsVal_int(obj2, &val3);
7137 if (!SWIG_IsOK(ecode3)) {
7138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7139 }
7140 arg3 = static_cast< int >(val3);
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 (arg1)->Offset(arg2,arg3);
7144 wxPyEndAllowThreads(__tstate);
7145 if (PyErr_Occurred()) SWIG_fail;
7146 }
7147 resultobj = SWIG_Py_Void();
7148 return resultobj;
7149 fail:
7150 return NULL;
7151 }
7152
7153
7154 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7155 PyObject *resultobj = 0;
7156 wxRect *arg1 = (wxRect *) 0 ;
7157 wxPoint *arg2 = 0 ;
7158 void *argp1 = 0 ;
7159 int res1 = 0 ;
7160 wxPoint temp2 ;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char * kwnames[] = {
7164 (char *) "self",(char *) "pt", NULL
7165 };
7166
7167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7169 if (!SWIG_IsOK(res1)) {
7170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7171 }
7172 arg1 = reinterpret_cast< wxRect * >(argp1);
7173 {
7174 arg2 = &temp2;
7175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7176 }
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 (arg1)->Offset((wxPoint const &)*arg2);
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 resultobj = SWIG_Py_Void();
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7191 PyObject *resultobj = 0;
7192 wxRect *arg1 = (wxRect *) 0 ;
7193 wxRect *arg2 = 0 ;
7194 wxRect result;
7195 void *argp1 = 0 ;
7196 int res1 = 0 ;
7197 wxRect temp2 ;
7198 PyObject * obj0 = 0 ;
7199 PyObject * obj1 = 0 ;
7200 char * kwnames[] = {
7201 (char *) "self",(char *) "rect", NULL
7202 };
7203
7204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7206 if (!SWIG_IsOK(res1)) {
7207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7208 }
7209 arg1 = reinterpret_cast< wxRect * >(argp1);
7210 {
7211 arg2 = &temp2;
7212 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7213 }
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (arg1)->Intersect((wxRect const &)*arg2);
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxRect *arg1 = (wxRect *) 0 ;
7230 wxRect *arg2 = 0 ;
7231 wxRect result;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 wxRect temp2 ;
7235 PyObject * obj0 = 0 ;
7236 PyObject * obj1 = 0 ;
7237 char * kwnames[] = {
7238 (char *) "self",(char *) "rect", NULL
7239 };
7240
7241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7243 if (!SWIG_IsOK(res1)) {
7244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7245 }
7246 arg1 = reinterpret_cast< wxRect * >(argp1);
7247 {
7248 arg2 = &temp2;
7249 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7250 }
7251 {
7252 PyThreadState* __tstate = wxPyBeginAllowThreads();
7253 result = (arg1)->Union((wxRect const &)*arg2);
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7258 return resultobj;
7259 fail:
7260 return NULL;
7261 }
7262
7263
7264 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7265 PyObject *resultobj = 0;
7266 wxRect *arg1 = (wxRect *) 0 ;
7267 wxRect *arg2 = 0 ;
7268 wxRect result;
7269 void *argp1 = 0 ;
7270 int res1 = 0 ;
7271 wxRect temp2 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 char * kwnames[] = {
7275 (char *) "self",(char *) "rect", NULL
7276 };
7277
7278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7280 if (!SWIG_IsOK(res1)) {
7281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7282 }
7283 arg1 = reinterpret_cast< wxRect * >(argp1);
7284 {
7285 arg2 = &temp2;
7286 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7287 }
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj = 0;
7303 wxRect *arg1 = (wxRect *) 0 ;
7304 wxRect *arg2 = 0 ;
7305 wxRect *result = 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 wxRect temp2 ;
7309 PyObject * obj0 = 0 ;
7310 PyObject * obj1 = 0 ;
7311 char * kwnames[] = {
7312 (char *) "self",(char *) "rect", NULL
7313 };
7314
7315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7317 if (!SWIG_IsOK(res1)) {
7318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7319 }
7320 arg1 = reinterpret_cast< wxRect * >(argp1);
7321 {
7322 arg2 = &temp2;
7323 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7324 }
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 {
7328 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7329 result = (wxRect *) &_result_ref;
7330 }
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj = 0;
7343 wxRect *arg1 = (wxRect *) 0 ;
7344 PyObject *arg2 = (PyObject *) 0 ;
7345 bool result;
7346 void *argp1 = 0 ;
7347 int res1 = 0 ;
7348 PyObject * obj0 = 0 ;
7349 PyObject * obj1 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "other", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) 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___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7358 }
7359 arg1 = reinterpret_cast< wxRect * >(argp1);
7360 arg2 = obj1;
7361 {
7362 result = (bool)wxRect___eq__(arg1,arg2);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 {
7366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj = 0;
7376 wxRect *arg1 = (wxRect *) 0 ;
7377 PyObject *arg2 = (PyObject *) 0 ;
7378 bool result;
7379 void *argp1 = 0 ;
7380 int res1 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "other", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 arg2 = obj1;
7394 {
7395 result = (bool)wxRect___ne__(arg1,arg2);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 {
7399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7400 }
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj = 0;
7409 wxRect *arg1 = (wxRect *) 0 ;
7410 int arg2 ;
7411 int arg3 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 int val2 ;
7416 int ecode2 = 0 ;
7417 int val3 ;
7418 int ecode3 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 PyObject * obj2 = 0 ;
7422 char * kwnames[] = {
7423 (char *) "self",(char *) "x",(char *) "y", NULL
7424 };
7425
7426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7430 }
7431 arg1 = reinterpret_cast< wxRect * >(argp1);
7432 ecode2 = SWIG_AsVal_int(obj1, &val2);
7433 if (!SWIG_IsOK(ecode2)) {
7434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7435 }
7436 arg2 = static_cast< int >(val2);
7437 ecode3 = SWIG_AsVal_int(obj2, &val3);
7438 if (!SWIG_IsOK(ecode3)) {
7439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7440 }
7441 arg3 = static_cast< int >(val3);
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj = 0;
7459 wxRect *arg1 = (wxRect *) 0 ;
7460 wxPoint *arg2 = 0 ;
7461 bool result;
7462 void *argp1 = 0 ;
7463 int res1 = 0 ;
7464 wxPoint temp2 ;
7465 PyObject * obj0 = 0 ;
7466 PyObject * obj1 = 0 ;
7467 char * kwnames[] = {
7468 (char *) "self",(char *) "pt", NULL
7469 };
7470
7471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7473 if (!SWIG_IsOK(res1)) {
7474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7475 }
7476 arg1 = reinterpret_cast< wxRect * >(argp1);
7477 {
7478 arg2 = &temp2;
7479 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj = 0;
7498 wxRect *arg1 = (wxRect *) 0 ;
7499 wxRect *arg2 = 0 ;
7500 bool result;
7501 void *argp1 = 0 ;
7502 int res1 = 0 ;
7503 wxRect temp2 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char * kwnames[] = {
7507 (char *) "self",(char *) "rect", NULL
7508 };
7509
7510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7512 if (!SWIG_IsOK(res1)) {
7513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7514 }
7515 arg1 = reinterpret_cast< wxRect * >(argp1);
7516 {
7517 arg2 = &temp2;
7518 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7519 }
7520 {
7521 PyThreadState* __tstate = wxPyBeginAllowThreads();
7522 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 {
7527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7528 }
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj = 0;
7537 wxRect *arg1 = (wxRect *) 0 ;
7538 wxRect *arg2 = 0 ;
7539 int arg3 = (int) wxBOTH ;
7540 wxRect result;
7541 void *argp1 = 0 ;
7542 int res1 = 0 ;
7543 wxRect temp2 ;
7544 int val3 ;
7545 int ecode3 = 0 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 PyObject * obj2 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "r",(char *) "dir", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7557 }
7558 arg1 = reinterpret_cast< wxRect * >(argp1);
7559 {
7560 arg2 = &temp2;
7561 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7562 }
7563 if (obj2) {
7564 ecode3 = SWIG_AsVal_int(obj2, &val3);
7565 if (!SWIG_IsOK(ecode3)) {
7566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7567 }
7568 arg3 = static_cast< int >(val3);
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 int arg2 ;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 int val2 ;
7590 int ecode2 = 0 ;
7591 PyObject *swig_obj[2] ;
7592
7593 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7597 }
7598 arg1 = reinterpret_cast< wxRect * >(argp1);
7599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7600 if (!SWIG_IsOK(ecode2)) {
7601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7602 }
7603 arg2 = static_cast< int >(val2);
7604 if (arg1) (arg1)->x = arg2;
7605
7606 resultobj = SWIG_Py_Void();
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7614 PyObject *resultobj = 0;
7615 wxRect *arg1 = (wxRect *) 0 ;
7616 int result;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 PyObject *swig_obj[1] ;
7620
7621 if (!args) SWIG_fail;
7622 swig_obj[0] = args;
7623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7626 }
7627 arg1 = reinterpret_cast< wxRect * >(argp1);
7628 result = (int) ((arg1)->x);
7629 resultobj = SWIG_From_int(static_cast< int >(result));
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxRect *arg1 = (wxRect *) 0 ;
7639 int arg2 ;
7640 void *argp1 = 0 ;
7641 int res1 = 0 ;
7642 int val2 ;
7643 int ecode2 = 0 ;
7644 PyObject *swig_obj[2] ;
7645
7646 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7648 if (!SWIG_IsOK(res1)) {
7649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7650 }
7651 arg1 = reinterpret_cast< wxRect * >(argp1);
7652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7653 if (!SWIG_IsOK(ecode2)) {
7654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7655 }
7656 arg2 = static_cast< int >(val2);
7657 if (arg1) (arg1)->y = arg2;
7658
7659 resultobj = SWIG_Py_Void();
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7667 PyObject *resultobj = 0;
7668 wxRect *arg1 = (wxRect *) 0 ;
7669 int result;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 PyObject *swig_obj[1] ;
7673
7674 if (!args) SWIG_fail;
7675 swig_obj[0] = args;
7676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7679 }
7680 arg1 = reinterpret_cast< wxRect * >(argp1);
7681 result = (int) ((arg1)->y);
7682 resultobj = SWIG_From_int(static_cast< int >(result));
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7690 PyObject *resultobj = 0;
7691 wxRect *arg1 = (wxRect *) 0 ;
7692 int arg2 ;
7693 void *argp1 = 0 ;
7694 int res1 = 0 ;
7695 int val2 ;
7696 int ecode2 = 0 ;
7697 PyObject *swig_obj[2] ;
7698
7699 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7701 if (!SWIG_IsOK(res1)) {
7702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7703 }
7704 arg1 = reinterpret_cast< wxRect * >(argp1);
7705 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7706 if (!SWIG_IsOK(ecode2)) {
7707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7708 }
7709 arg2 = static_cast< int >(val2);
7710 if (arg1) (arg1)->width = arg2;
7711
7712 resultobj = SWIG_Py_Void();
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7720 PyObject *resultobj = 0;
7721 wxRect *arg1 = (wxRect *) 0 ;
7722 int result;
7723 void *argp1 = 0 ;
7724 int res1 = 0 ;
7725 PyObject *swig_obj[1] ;
7726
7727 if (!args) SWIG_fail;
7728 swig_obj[0] = args;
7729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7730 if (!SWIG_IsOK(res1)) {
7731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7732 }
7733 arg1 = reinterpret_cast< wxRect * >(argp1);
7734 result = (int) ((arg1)->width);
7735 resultobj = SWIG_From_int(static_cast< int >(result));
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7743 PyObject *resultobj = 0;
7744 wxRect *arg1 = (wxRect *) 0 ;
7745 int arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 int val2 ;
7749 int ecode2 = 0 ;
7750 PyObject *swig_obj[2] ;
7751
7752 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7756 }
7757 arg1 = reinterpret_cast< wxRect * >(argp1);
7758 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7761 }
7762 arg2 = static_cast< int >(val2);
7763 if (arg1) (arg1)->height = arg2;
7764
7765 resultobj = SWIG_Py_Void();
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7773 PyObject *resultobj = 0;
7774 wxRect *arg1 = (wxRect *) 0 ;
7775 int result;
7776 void *argp1 = 0 ;
7777 int res1 = 0 ;
7778 PyObject *swig_obj[1] ;
7779
7780 if (!args) SWIG_fail;
7781 swig_obj[0] = args;
7782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7785 }
7786 arg1 = reinterpret_cast< wxRect * >(argp1);
7787 result = (int) ((arg1)->height);
7788 resultobj = SWIG_From_int(static_cast< int >(result));
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj = 0;
7797 wxRect *arg1 = (wxRect *) 0 ;
7798 int arg2 = (int) 0 ;
7799 int arg3 = (int) 0 ;
7800 int arg4 = (int) 0 ;
7801 int arg5 = (int) 0 ;
7802 void *argp1 = 0 ;
7803 int res1 = 0 ;
7804 int val2 ;
7805 int ecode2 = 0 ;
7806 int val3 ;
7807 int ecode3 = 0 ;
7808 int val4 ;
7809 int ecode4 = 0 ;
7810 int val5 ;
7811 int ecode5 = 0 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 PyObject * obj2 = 0 ;
7815 PyObject * obj3 = 0 ;
7816 PyObject * obj4 = 0 ;
7817 char * kwnames[] = {
7818 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7819 };
7820
7821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7825 }
7826 arg1 = reinterpret_cast< wxRect * >(argp1);
7827 if (obj1) {
7828 ecode2 = SWIG_AsVal_int(obj1, &val2);
7829 if (!SWIG_IsOK(ecode2)) {
7830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7831 }
7832 arg2 = static_cast< int >(val2);
7833 }
7834 if (obj2) {
7835 ecode3 = SWIG_AsVal_int(obj2, &val3);
7836 if (!SWIG_IsOK(ecode3)) {
7837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7838 }
7839 arg3 = static_cast< int >(val3);
7840 }
7841 if (obj3) {
7842 ecode4 = SWIG_AsVal_int(obj3, &val4);
7843 if (!SWIG_IsOK(ecode4)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7845 }
7846 arg4 = static_cast< int >(val4);
7847 }
7848 if (obj4) {
7849 ecode5 = SWIG_AsVal_int(obj4, &val5);
7850 if (!SWIG_IsOK(ecode5)) {
7851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7852 }
7853 arg5 = static_cast< int >(val5);
7854 }
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7858 wxPyEndAllowThreads(__tstate);
7859 if (PyErr_Occurred()) SWIG_fail;
7860 }
7861 resultobj = SWIG_Py_Void();
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 PyObject *result = 0 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 PyObject *swig_obj[1] ;
7875
7876 if (!args) SWIG_fail;
7877 swig_obj[0] = args;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (PyObject *)wxRect_Get(arg1);
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = result;
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *obj;
7898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7899 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7900 return SWIG_Py_Void();
7901 }
7902
7903 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7904 return SWIG_Python_InitShadowInstance(args);
7905 }
7906
7907 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7908 PyObject *resultobj = 0;
7909 wxRect *arg1 = (wxRect *) 0 ;
7910 wxRect *arg2 = (wxRect *) 0 ;
7911 PyObject *result = 0 ;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 void *argp2 = 0 ;
7915 int res2 = 0 ;
7916 PyObject * obj0 = 0 ;
7917 PyObject * obj1 = 0 ;
7918 char * kwnames[] = {
7919 (char *) "r1",(char *) "r2", NULL
7920 };
7921
7922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7924 if (!SWIG_IsOK(res1)) {
7925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7926 }
7927 arg1 = reinterpret_cast< wxRect * >(argp1);
7928 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7929 if (!SWIG_IsOK(res2)) {
7930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7931 }
7932 arg2 = reinterpret_cast< wxRect * >(argp2);
7933 {
7934 if (!wxPyCheckForApp()) SWIG_fail;
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (PyObject *)wxIntersectRect(arg1,arg2);
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 resultobj = result;
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7948 PyObject *resultobj = 0;
7949 double arg1 = (double) 0.0 ;
7950 double arg2 = (double) 0.0 ;
7951 wxPoint2D *result = 0 ;
7952 double val1 ;
7953 int ecode1 = 0 ;
7954 double val2 ;
7955 int ecode2 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "x",(char *) "y", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7963 if (obj0) {
7964 ecode1 = SWIG_AsVal_double(obj0, &val1);
7965 if (!SWIG_IsOK(ecode1)) {
7966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7967 }
7968 arg1 = static_cast< double >(val1);
7969 }
7970 if (obj1) {
7971 ecode2 = SWIG_AsVal_double(obj1, &val2);
7972 if (!SWIG_IsOK(ecode2)) {
7973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7974 }
7975 arg2 = static_cast< double >(val2);
7976 }
7977 {
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7984 return resultobj;
7985 fail:
7986 return NULL;
7987 }
7988
7989
7990 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7991 PyObject *resultobj = 0;
7992 wxPoint2D *arg1 = 0 ;
7993 wxPoint2D *result = 0 ;
7994 wxPoint2D temp1 ;
7995 PyObject * obj0 = 0 ;
7996 char * kwnames[] = {
7997 (char *) "pt", NULL
7998 };
7999
8000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8001 {
8002 arg1 = &temp1;
8003 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8004 }
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj = 0;
8020 wxPoint *arg1 = 0 ;
8021 wxPoint2D *result = 0 ;
8022 wxPoint temp1 ;
8023 PyObject * obj0 = 0 ;
8024 char * kwnames[] = {
8025 (char *) "pt", NULL
8026 };
8027
8028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8029 {
8030 arg1 = &temp1;
8031 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8047 PyObject *resultobj = 0;
8048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8049 int *arg2 = (int *) 0 ;
8050 int *arg3 = (int *) 0 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 int temp2 ;
8054 int res2 = SWIG_TMPOBJ ;
8055 int temp3 ;
8056 int res3 = SWIG_TMPOBJ ;
8057 PyObject *swig_obj[1] ;
8058
8059 arg2 = &temp2;
8060 arg3 = &temp3;
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8066 }
8067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 if (SWIG_IsTmpObj(res2)) {
8076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8077 } else {
8078 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8080 }
8081 if (SWIG_IsTmpObj(res3)) {
8082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8083 } else {
8084 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8096 int *arg2 = (int *) 0 ;
8097 int *arg3 = (int *) 0 ;
8098 void *argp1 = 0 ;
8099 int res1 = 0 ;
8100 int temp2 ;
8101 int res2 = SWIG_TMPOBJ ;
8102 int temp3 ;
8103 int res3 = SWIG_TMPOBJ ;
8104 PyObject *swig_obj[1] ;
8105
8106 arg2 = &temp2;
8107 arg3 = &temp3;
8108 if (!args) SWIG_fail;
8109 swig_obj[0] = args;
8110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8111 if (!SWIG_IsOK(res1)) {
8112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8113 }
8114 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_Py_Void();
8122 if (SWIG_IsTmpObj(res2)) {
8123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8124 } else {
8125 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8127 }
8128 if (SWIG_IsTmpObj(res3)) {
8129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8130 } else {
8131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8133 }
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8141 PyObject *resultobj = 0;
8142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8143 double result;
8144 void *argp1 = 0 ;
8145 int res1 = 0 ;
8146 PyObject *swig_obj[1] ;
8147
8148 if (!args) SWIG_fail;
8149 swig_obj[0] = args;
8150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8151 if (!SWIG_IsOK(res1)) {
8152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8153 }
8154 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8158 wxPyEndAllowThreads(__tstate);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 resultobj = SWIG_From_double(static_cast< double >(result));
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169 PyObject *resultobj = 0;
8170 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8171 double result;
8172 void *argp1 = 0 ;
8173 int res1 = 0 ;
8174 PyObject *swig_obj[1] ;
8175
8176 if (!args) SWIG_fail;
8177 swig_obj[0] = args;
8178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8179 if (!SWIG_IsOK(res1)) {
8180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8181 }
8182 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_From_double(static_cast< double >(result));
8190 return resultobj;
8191 fail:
8192 return NULL;
8193 }
8194
8195
8196 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8197 PyObject *resultobj = 0;
8198 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8199 double arg2 ;
8200 void *argp1 = 0 ;
8201 int res1 = 0 ;
8202 double val2 ;
8203 int ecode2 = 0 ;
8204 PyObject * obj0 = 0 ;
8205 PyObject * obj1 = 0 ;
8206 char * kwnames[] = {
8207 (char *) "self",(char *) "length", NULL
8208 };
8209
8210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8212 if (!SWIG_IsOK(res1)) {
8213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8214 }
8215 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8216 ecode2 = SWIG_AsVal_double(obj1, &val2);
8217 if (!SWIG_IsOK(ecode2)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8219 }
8220 arg2 = static_cast< double >(val2);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 (arg1)->SetVectorLength(arg2);
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 resultobj = SWIG_Py_Void();
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8235 PyObject *resultobj = 0;
8236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8237 double arg2 ;
8238 void *argp1 = 0 ;
8239 int res1 = 0 ;
8240 double val2 ;
8241 int ecode2 = 0 ;
8242 PyObject * obj0 = 0 ;
8243 PyObject * obj1 = 0 ;
8244 char * kwnames[] = {
8245 (char *) "self",(char *) "degrees", NULL
8246 };
8247
8248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8252 }
8253 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8254 ecode2 = SWIG_AsVal_double(obj1, &val2);
8255 if (!SWIG_IsOK(ecode2)) {
8256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8257 }
8258 arg2 = static_cast< double >(val2);
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->SetVectorAngle(arg2);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj = 0;
8274 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8275 wxPoint2D *arg2 = 0 ;
8276 double result;
8277 void *argp1 = 0 ;
8278 int res1 = 0 ;
8279 wxPoint2D temp2 ;
8280 PyObject * obj0 = 0 ;
8281 PyObject * obj1 = 0 ;
8282 char * kwnames[] = {
8283 (char *) "self",(char *) "pt", NULL
8284 };
8285
8286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8288 if (!SWIG_IsOK(res1)) {
8289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8290 }
8291 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8292 {
8293 arg2 = &temp2;
8294 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8295 }
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 resultobj = SWIG_From_double(static_cast< double >(result));
8303 return resultobj;
8304 fail:
8305 return NULL;
8306 }
8307
8308
8309 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8310 PyObject *resultobj = 0;
8311 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8312 wxPoint2D *arg2 = 0 ;
8313 double result;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 wxPoint2D temp2 ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char * kwnames[] = {
8320 (char *) "self",(char *) "pt", NULL
8321 };
8322
8323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8327 }
8328 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8329 {
8330 arg2 = &temp2;
8331 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8332 }
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 resultobj = SWIG_From_double(static_cast< double >(result));
8340 return resultobj;
8341 fail:
8342 return NULL;
8343 }
8344
8345
8346 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj = 0;
8348 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8349 wxPoint2D *arg2 = 0 ;
8350 double result;
8351 void *argp1 = 0 ;
8352 int res1 = 0 ;
8353 wxPoint2D temp2 ;
8354 PyObject * obj0 = 0 ;
8355 PyObject * obj1 = 0 ;
8356 char * kwnames[] = {
8357 (char *) "self",(char *) "vec", NULL
8358 };
8359
8360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8362 if (!SWIG_IsOK(res1)) {
8363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8364 }
8365 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8366 {
8367 arg2 = &temp2;
8368 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8369 }
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_From_double(static_cast< double >(result));
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8386 wxPoint2D *arg2 = 0 ;
8387 double result;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 wxPoint2D temp2 ;
8391 PyObject * obj0 = 0 ;
8392 PyObject * obj1 = 0 ;
8393 char * kwnames[] = {
8394 (char *) "self",(char *) "vec", NULL
8395 };
8396
8397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8399 if (!SWIG_IsOK(res1)) {
8400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8401 }
8402 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8403 {
8404 arg2 = &temp2;
8405 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8406 }
8407 {
8408 PyThreadState* __tstate = wxPyBeginAllowThreads();
8409 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_From_double(static_cast< double >(result));
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 wxPoint2D result;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 PyObject *swig_obj[1] ;
8427
8428 if (!args) SWIG_fail;
8429 swig_obj[0] = args;
8430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8433 }
8434 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8435 {
8436 PyThreadState* __tstate = wxPyBeginAllowThreads();
8437 result = (arg1)->operator -();
8438 wxPyEndAllowThreads(__tstate);
8439 if (PyErr_Occurred()) SWIG_fail;
8440 }
8441 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8442 return resultobj;
8443 fail:
8444 return NULL;
8445 }
8446
8447
8448 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8449 PyObject *resultobj = 0;
8450 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8451 wxPoint2D *arg2 = 0 ;
8452 wxPoint2D *result = 0 ;
8453 void *argp1 = 0 ;
8454 int res1 = 0 ;
8455 wxPoint2D temp2 ;
8456 PyObject * obj0 = 0 ;
8457 PyObject * obj1 = 0 ;
8458 char * kwnames[] = {
8459 (char *) "self",(char *) "pt", NULL
8460 };
8461
8462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8466 }
8467 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8468 {
8469 arg2 = &temp2;
8470 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8471 }
8472 {
8473 PyThreadState* __tstate = wxPyBeginAllowThreads();
8474 {
8475 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8476 result = (wxPoint2D *) &_result_ref;
8477 }
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 wxPoint2D *arg2 = 0 ;
8492 wxPoint2D *result = 0 ;
8493 void *argp1 = 0 ;
8494 int res1 = 0 ;
8495 wxPoint2D temp2 ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char * kwnames[] = {
8499 (char *) "self",(char *) "pt", NULL
8500 };
8501
8502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8504 if (!SWIG_IsOK(res1)) {
8505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8506 }
8507 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8508 {
8509 arg2 = &temp2;
8510 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8511 }
8512 {
8513 PyThreadState* __tstate = wxPyBeginAllowThreads();
8514 {
8515 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8516 result = (wxPoint2D *) &_result_ref;
8517 }
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8522 return resultobj;
8523 fail:
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8529 PyObject *resultobj = 0;
8530 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8531 wxPoint2D *arg2 = 0 ;
8532 wxPoint2D *result = 0 ;
8533 void *argp1 = 0 ;
8534 int res1 = 0 ;
8535 wxPoint2D temp2 ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char * kwnames[] = {
8539 (char *) "self",(char *) "pt", NULL
8540 };
8541
8542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8546 }
8547 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8548 {
8549 arg2 = &temp2;
8550 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8551 }
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 {
8555 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8556 result = (wxPoint2D *) &_result_ref;
8557 }
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj = 0;
8570 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8571 wxPoint2D *arg2 = 0 ;
8572 wxPoint2D *result = 0 ;
8573 void *argp1 = 0 ;
8574 int res1 = 0 ;
8575 wxPoint2D temp2 ;
8576 PyObject * obj0 = 0 ;
8577 PyObject * obj1 = 0 ;
8578 char * kwnames[] = {
8579 (char *) "self",(char *) "pt", NULL
8580 };
8581
8582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8584 if (!SWIG_IsOK(res1)) {
8585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8586 }
8587 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8588 {
8589 arg2 = &temp2;
8590 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8591 }
8592 {
8593 PyThreadState* __tstate = wxPyBeginAllowThreads();
8594 {
8595 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8596 result = (wxPoint2D *) &_result_ref;
8597 }
8598 wxPyEndAllowThreads(__tstate);
8599 if (PyErr_Occurred()) SWIG_fail;
8600 }
8601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8602 return resultobj;
8603 fail:
8604 return NULL;
8605 }
8606
8607
8608 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8609 PyObject *resultobj = 0;
8610 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8611 PyObject *arg2 = (PyObject *) 0 ;
8612 bool result;
8613 void *argp1 = 0 ;
8614 int res1 = 0 ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 char * kwnames[] = {
8618 (char *) "self",(char *) "other", NULL
8619 };
8620
8621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8623 if (!SWIG_IsOK(res1)) {
8624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8625 }
8626 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8627 arg2 = obj1;
8628 {
8629 result = (bool)wxPoint2D___eq__(arg1,arg2);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 {
8633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj = 0;
8643 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8644 PyObject *arg2 = (PyObject *) 0 ;
8645 bool result;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 PyObject * obj0 = 0 ;
8649 PyObject * obj1 = 0 ;
8650 char * kwnames[] = {
8651 (char *) "self",(char *) "other", NULL
8652 };
8653
8654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8658 }
8659 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8660 arg2 = obj1;
8661 {
8662 result = (bool)wxPoint2D___ne__(arg1,arg2);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 {
8666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8667 }
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8675 PyObject *resultobj = 0;
8676 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8677 double arg2 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 double val2 ;
8681 int ecode2 = 0 ;
8682 PyObject *swig_obj[2] ;
8683
8684 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8686 if (!SWIG_IsOK(res1)) {
8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8688 }
8689 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8690 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8691 if (!SWIG_IsOK(ecode2)) {
8692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8693 }
8694 arg2 = static_cast< double >(val2);
8695 if (arg1) (arg1)->m_x = arg2;
8696
8697 resultobj = SWIG_Py_Void();
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8705 PyObject *resultobj = 0;
8706 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8707 double result;
8708 void *argp1 = 0 ;
8709 int res1 = 0 ;
8710 PyObject *swig_obj[1] ;
8711
8712 if (!args) SWIG_fail;
8713 swig_obj[0] = args;
8714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8715 if (!SWIG_IsOK(res1)) {
8716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8717 }
8718 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8719 result = (double) ((arg1)->m_x);
8720 resultobj = SWIG_From_double(static_cast< double >(result));
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8728 PyObject *resultobj = 0;
8729 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8730 double arg2 ;
8731 void *argp1 = 0 ;
8732 int res1 = 0 ;
8733 double val2 ;
8734 int ecode2 = 0 ;
8735 PyObject *swig_obj[2] ;
8736
8737 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8739 if (!SWIG_IsOK(res1)) {
8740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8741 }
8742 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8743 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8744 if (!SWIG_IsOK(ecode2)) {
8745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8746 }
8747 arg2 = static_cast< double >(val2);
8748 if (arg1) (arg1)->m_y = arg2;
8749
8750 resultobj = SWIG_Py_Void();
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8758 PyObject *resultobj = 0;
8759 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8760 double result;
8761 void *argp1 = 0 ;
8762 int res1 = 0 ;
8763 PyObject *swig_obj[1] ;
8764
8765 if (!args) SWIG_fail;
8766 swig_obj[0] = args;
8767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8770 }
8771 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8772 result = (double) ((arg1)->m_y);
8773 resultobj = SWIG_From_double(static_cast< double >(result));
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = 0;
8782 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8783 double arg2 = (double) 0 ;
8784 double arg3 = (double) 0 ;
8785 void *argp1 = 0 ;
8786 int res1 = 0 ;
8787 double val2 ;
8788 int ecode2 = 0 ;
8789 double val3 ;
8790 int ecode3 = 0 ;
8791 PyObject * obj0 = 0 ;
8792 PyObject * obj1 = 0 ;
8793 PyObject * obj2 = 0 ;
8794 char * kwnames[] = {
8795 (char *) "self",(char *) "x",(char *) "y", NULL
8796 };
8797
8798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8800 if (!SWIG_IsOK(res1)) {
8801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8802 }
8803 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8804 if (obj1) {
8805 ecode2 = SWIG_AsVal_double(obj1, &val2);
8806 if (!SWIG_IsOK(ecode2)) {
8807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8808 }
8809 arg2 = static_cast< double >(val2);
8810 }
8811 if (obj2) {
8812 ecode3 = SWIG_AsVal_double(obj2, &val3);
8813 if (!SWIG_IsOK(ecode3)) {
8814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8815 }
8816 arg3 = static_cast< double >(val3);
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 wxPoint2D_Set(arg1,arg2,arg3);
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_Py_Void();
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 PyObject *result = 0 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 PyObject *swig_obj[1] ;
8838
8839 if (!args) SWIG_fail;
8840 swig_obj[0] = args;
8841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 result = (PyObject *)wxPoint2D_Get(arg1);
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 resultobj = result;
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8860 PyObject *obj;
8861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8863 return SWIG_Py_Void();
8864 }
8865
8866 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8867 return SWIG_Python_InitShadowInstance(args);
8868 }
8869
8870 SWIGINTERN int DefaultPosition_set(PyObject *) {
8871 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8872 return 1;
8873 }
8874
8875
8876 SWIGINTERN PyObject *DefaultPosition_get(void) {
8877 PyObject *pyobj = 0;
8878
8879 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8880 return pyobj;
8881 }
8882
8883
8884 SWIGINTERN int DefaultSize_set(PyObject *) {
8885 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8886 return 1;
8887 }
8888
8889
8890 SWIGINTERN PyObject *DefaultSize_get(void) {
8891 PyObject *pyobj = 0;
8892
8893 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8894 return pyobj;
8895 }
8896
8897
8898 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj = 0;
8900 PyObject *arg1 = (PyObject *) 0 ;
8901 wxPyInputStream *result = 0 ;
8902 PyObject * obj0 = 0 ;
8903 char * kwnames[] = {
8904 (char *) "p", NULL
8905 };
8906
8907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8908 arg1 = obj0;
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8923 PyObject *resultobj = 0;
8924 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8925 void *argp1 = 0 ;
8926 int res1 = 0 ;
8927 PyObject *swig_obj[1] ;
8928
8929 if (!args) SWIG_fail;
8930 swig_obj[0] = args;
8931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8934 }
8935 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 delete arg1;
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 resultobj = SWIG_Py_Void();
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 PyObject *resultobj = 0;
8952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8953 void *argp1 = 0 ;
8954 int res1 = 0 ;
8955 PyObject *swig_obj[1] ;
8956
8957 if (!args) SWIG_fail;
8958 swig_obj[0] = args;
8959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8960 if (!SWIG_IsOK(res1)) {
8961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8962 }
8963 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 (arg1)->close();
8967 wxPyEndAllowThreads(__tstate);
8968 if (PyErr_Occurred()) SWIG_fail;
8969 }
8970 resultobj = SWIG_Py_Void();
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 PyObject *resultobj = 0;
8979 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8980 void *argp1 = 0 ;
8981 int res1 = 0 ;
8982 PyObject *swig_obj[1] ;
8983
8984 if (!args) SWIG_fail;
8985 swig_obj[0] = args;
8986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8987 if (!SWIG_IsOK(res1)) {
8988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8989 }
8990 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 (arg1)->flush();
8994 wxPyEndAllowThreads(__tstate);
8995 if (PyErr_Occurred()) SWIG_fail;
8996 }
8997 resultobj = SWIG_Py_Void();
8998 return resultobj;
8999 fail:
9000 return NULL;
9001 }
9002
9003
9004 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9005 PyObject *resultobj = 0;
9006 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9007 bool result;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject *swig_obj[1] ;
9011
9012 if (!args) SWIG_fail;
9013 swig_obj[0] = args;
9014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9015 if (!SWIG_IsOK(res1)) {
9016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9017 }
9018 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (bool)(arg1)->eof();
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9027 }
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj = 0;
9036 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9037 int arg2 = (int) -1 ;
9038 PyObject *result = 0 ;
9039 void *argp1 = 0 ;
9040 int res1 = 0 ;
9041 int val2 ;
9042 int ecode2 = 0 ;
9043 PyObject * obj0 = 0 ;
9044 PyObject * obj1 = 0 ;
9045 char * kwnames[] = {
9046 (char *) "self",(char *) "size", NULL
9047 };
9048
9049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9053 }
9054 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9055 if (obj1) {
9056 ecode2 = SWIG_AsVal_int(obj1, &val2);
9057 if (!SWIG_IsOK(ecode2)) {
9058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9059 }
9060 arg2 = static_cast< int >(val2);
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = (PyObject *)(arg1)->read(arg2);
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = result;
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 int arg2 = (int) -1 ;
9079 PyObject *result = 0 ;
9080 void *argp1 = 0 ;
9081 int res1 = 0 ;
9082 int val2 ;
9083 int ecode2 = 0 ;
9084 PyObject * obj0 = 0 ;
9085 PyObject * obj1 = 0 ;
9086 char * kwnames[] = {
9087 (char *) "self",(char *) "size", NULL
9088 };
9089
9090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9092 if (!SWIG_IsOK(res1)) {
9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9094 }
9095 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9096 if (obj1) {
9097 ecode2 = SWIG_AsVal_int(obj1, &val2);
9098 if (!SWIG_IsOK(ecode2)) {
9099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9100 }
9101 arg2 = static_cast< int >(val2);
9102 }
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 result = (PyObject *)(arg1)->readline(arg2);
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 resultobj = result;
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9119 int arg2 = (int) -1 ;
9120 PyObject *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 int val2 ;
9124 int ecode2 = 0 ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127 char * kwnames[] = {
9128 (char *) "self",(char *) "sizehint", NULL
9129 };
9130
9131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9133 if (!SWIG_IsOK(res1)) {
9134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9135 }
9136 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9137 if (obj1) {
9138 ecode2 = SWIG_AsVal_int(obj1, &val2);
9139 if (!SWIG_IsOK(ecode2)) {
9140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9141 }
9142 arg2 = static_cast< int >(val2);
9143 }
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (PyObject *)(arg1)->readlines(arg2);
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 resultobj = result;
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj = 0;
9159 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9160 int arg2 ;
9161 int arg3 = (int) 0 ;
9162 void *argp1 = 0 ;
9163 int res1 = 0 ;
9164 int val2 ;
9165 int ecode2 = 0 ;
9166 int val3 ;
9167 int ecode3 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "offset",(char *) "whence", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 if (obj2) {
9187 ecode3 = SWIG_AsVal_int(obj2, &val3);
9188 if (!SWIG_IsOK(ecode3)) {
9189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9190 }
9191 arg3 = static_cast< int >(val3);
9192 }
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 (arg1)->seek(arg2,arg3);
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 resultobj = SWIG_Py_Void();
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 PyObject *resultobj = 0;
9208 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9209 int result;
9210 void *argp1 = 0 ;
9211 int res1 = 0 ;
9212 PyObject *swig_obj[1] ;
9213
9214 if (!args) SWIG_fail;
9215 swig_obj[0] = args;
9216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (int)(arg1)->tell();
9224 wxPyEndAllowThreads(__tstate);
9225 if (PyErr_Occurred()) SWIG_fail;
9226 }
9227 resultobj = SWIG_From_int(static_cast< int >(result));
9228 return resultobj;
9229 fail:
9230 return NULL;
9231 }
9232
9233
9234 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9235 PyObject *resultobj = 0;
9236 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9237 char result;
9238 void *argp1 = 0 ;
9239 int res1 = 0 ;
9240 PyObject *swig_obj[1] ;
9241
9242 if (!args) SWIG_fail;
9243 swig_obj[0] = args;
9244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9245 if (!SWIG_IsOK(res1)) {
9246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9247 }
9248 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 result = (char)(arg1)->Peek();
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 resultobj = SWIG_From_char(static_cast< char >(result));
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 PyObject *resultobj = 0;
9264 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9265 char result;
9266 void *argp1 = 0 ;
9267 int res1 = 0 ;
9268 PyObject *swig_obj[1] ;
9269
9270 if (!args) SWIG_fail;
9271 swig_obj[0] = args;
9272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9273 if (!SWIG_IsOK(res1)) {
9274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9275 }
9276 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 result = (char)(arg1)->GetC();
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_From_char(static_cast< char >(result));
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9293 size_t result;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9303 }
9304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (size_t)(arg1)->LastRead();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9319 PyObject *resultobj = 0;
9320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9321 bool result;
9322 void *argp1 = 0 ;
9323 int res1 = 0 ;
9324 PyObject *swig_obj[1] ;
9325
9326 if (!args) SWIG_fail;
9327 swig_obj[0] = args;
9328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9329 if (!SWIG_IsOK(res1)) {
9330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9331 }
9332 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (bool)(arg1)->CanRead();
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 {
9340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9341 }
9342 return resultobj;
9343 fail:
9344 return NULL;
9345 }
9346
9347
9348 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9349 PyObject *resultobj = 0;
9350 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9351 bool result;
9352 void *argp1 = 0 ;
9353 int res1 = 0 ;
9354 PyObject *swig_obj[1] ;
9355
9356 if (!args) SWIG_fail;
9357 swig_obj[0] = args;
9358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9359 if (!SWIG_IsOK(res1)) {
9360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9361 }
9362 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (bool)(arg1)->Eof();
9366 wxPyEndAllowThreads(__tstate);
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 {
9370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9371 }
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj = 0;
9380 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9381 char arg2 ;
9382 bool result;
9383 void *argp1 = 0 ;
9384 int res1 = 0 ;
9385 char val2 ;
9386 int ecode2 = 0 ;
9387 PyObject * obj0 = 0 ;
9388 PyObject * obj1 = 0 ;
9389 char * kwnames[] = {
9390 (char *) "self",(char *) "c", NULL
9391 };
9392
9393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9395 if (!SWIG_IsOK(res1)) {
9396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9397 }
9398 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9399 ecode2 = SWIG_AsVal_char(obj1, &val2);
9400 if (!SWIG_IsOK(ecode2)) {
9401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9402 }
9403 arg2 = static_cast< char >(val2);
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (bool)(arg1)->Ungetch(arg2);
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj = 0;
9421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9422 long arg2 ;
9423 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9424 long result;
9425 void *argp1 = 0 ;
9426 int res1 = 0 ;
9427 long val2 ;
9428 int ecode2 = 0 ;
9429 int val3 ;
9430 int ecode3 = 0 ;
9431 PyObject * obj0 = 0 ;
9432 PyObject * obj1 = 0 ;
9433 PyObject * obj2 = 0 ;
9434 char * kwnames[] = {
9435 (char *) "self",(char *) "pos",(char *) "mode", NULL
9436 };
9437
9438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9442 }
9443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9444 ecode2 = SWIG_AsVal_long(obj1, &val2);
9445 if (!SWIG_IsOK(ecode2)) {
9446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9447 }
9448 arg2 = static_cast< long >(val2);
9449 if (obj2) {
9450 ecode3 = SWIG_AsVal_int(obj2, &val3);
9451 if (!SWIG_IsOK(ecode3)) {
9452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9453 }
9454 arg3 = static_cast< wxSeekMode >(val3);
9455 }
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (long)(arg1)->SeekI(arg2,arg3);
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_From_long(static_cast< long >(result));
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9470 PyObject *resultobj = 0;
9471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9472 long result;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 PyObject *swig_obj[1] ;
9476
9477 if (!args) SWIG_fail;
9478 swig_obj[0] = args;
9479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9482 }
9483 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9484 {
9485 PyThreadState* __tstate = wxPyBeginAllowThreads();
9486 result = (long)(arg1)->TellI();
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_From_long(static_cast< long >(result));
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9498 PyObject *obj;
9499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9500 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9501 return SWIG_Py_Void();
9502 }
9503
9504 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9505 return SWIG_Python_InitShadowInstance(args);
9506 }
9507
9508 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9511 PyObject *arg2 = (PyObject *) 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 char * kwnames[] = {
9517 (char *) "self",(char *) "obj", NULL
9518 };
9519
9520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9524 }
9525 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9526 arg2 = obj1;
9527 {
9528 PyThreadState* __tstate = wxPyBeginAllowThreads();
9529 wxOutputStream_write(arg1,arg2);
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 resultobj = SWIG_Py_Void();
9534 return resultobj;
9535 fail:
9536 return NULL;
9537 }
9538
9539
9540 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9541 PyObject *resultobj = 0;
9542 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9543 size_t result;
9544 void *argp1 = 0 ;
9545 int res1 = 0 ;
9546 PyObject *swig_obj[1] ;
9547
9548 if (!args) SWIG_fail;
9549 swig_obj[0] = args;
9550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9551 if (!SWIG_IsOK(res1)) {
9552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9553 }
9554 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569 PyObject *obj;
9570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9571 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9572 return SWIG_Py_Void();
9573 }
9574
9575 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj = 0;
9577 wxInputStream *arg1 = (wxInputStream *) 0 ;
9578 wxString *arg2 = 0 ;
9579 wxString *arg3 = 0 ;
9580 wxString *arg4 = 0 ;
9581 wxDateTime arg5 ;
9582 wxFSFile *result = 0 ;
9583 wxPyInputStream *temp1 ;
9584 bool temp2 = false ;
9585 bool temp3 = false ;
9586 bool temp4 = false ;
9587 void *argp5 ;
9588 int res5 = 0 ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 PyObject * obj2 = 0 ;
9592 PyObject * obj3 = 0 ;
9593 PyObject * obj4 = 0 ;
9594 char * kwnames[] = {
9595 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9596 };
9597
9598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9599 {
9600 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9601 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9602 } else {
9603 PyErr_Clear(); // clear the failure of the wxPyConvert above
9604 arg1 = wxPyCBInputStream_create(obj0, true);
9605 if (arg1 == NULL) {
9606 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9607 SWIG_fail;
9608 }
9609 }
9610 }
9611 {
9612 arg2 = wxString_in_helper(obj1);
9613 if (arg2 == NULL) SWIG_fail;
9614 temp2 = true;
9615 }
9616 {
9617 arg3 = wxString_in_helper(obj2);
9618 if (arg3 == NULL) SWIG_fail;
9619 temp3 = true;
9620 }
9621 {
9622 arg4 = wxString_in_helper(obj3);
9623 if (arg4 == NULL) SWIG_fail;
9624 temp4 = true;
9625 }
9626 {
9627 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9628 if (!SWIG_IsOK(res5)) {
9629 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9630 }
9631 if (!argp5) {
9632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9633 } else {
9634 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9635 arg5 = *temp;
9636 if (SWIG_IsNewObj(res5)) delete temp;
9637 }
9638 }
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9646 {
9647 if (temp2)
9648 delete arg2;
9649 }
9650 {
9651 if (temp3)
9652 delete arg3;
9653 }
9654 {
9655 if (temp4)
9656 delete arg4;
9657 }
9658 return resultobj;
9659 fail:
9660 {
9661 if (temp2)
9662 delete arg2;
9663 }
9664 {
9665 if (temp3)
9666 delete arg3;
9667 }
9668 {
9669 if (temp4)
9670 delete arg4;
9671 }
9672 return NULL;
9673 }
9674
9675
9676 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9677 PyObject *resultobj = 0;
9678 wxFSFile *arg1 = (wxFSFile *) 0 ;
9679 void *argp1 = 0 ;
9680 int res1 = 0 ;
9681 PyObject *swig_obj[1] ;
9682
9683 if (!args) SWIG_fail;
9684 swig_obj[0] = args;
9685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9686 if (!SWIG_IsOK(res1)) {
9687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9688 }
9689 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 delete arg1;
9693
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_Py_Void();
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9705 PyObject *resultobj = 0;
9706 wxFSFile *arg1 = (wxFSFile *) 0 ;
9707 wxInputStream *result = 0 ;
9708 void *argp1 = 0 ;
9709 int res1 = 0 ;
9710 PyObject *swig_obj[1] ;
9711
9712 if (!args) SWIG_fail;
9713 swig_obj[0] = args;
9714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9715 if (!SWIG_IsOK(res1)) {
9716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9717 }
9718 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (wxInputStream *)(arg1)->GetStream();
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 {
9726 wxPyInputStream * _ptr = NULL;
9727
9728 if (result) {
9729 _ptr = new wxPyInputStream(result);
9730 }
9731 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9732 }
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9740 PyObject *resultobj = 0;
9741 wxFSFile *arg1 = (wxFSFile *) 0 ;
9742 wxString *result = 0 ;
9743 void *argp1 = 0 ;
9744 int res1 = 0 ;
9745 PyObject *swig_obj[1] ;
9746
9747 if (!args) SWIG_fail;
9748 swig_obj[0] = args;
9749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9750 if (!SWIG_IsOK(res1)) {
9751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9752 }
9753 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9754 {
9755 PyThreadState* __tstate = wxPyBeginAllowThreads();
9756 {
9757 wxString const &_result_ref = (arg1)->GetMimeType();
9758 result = (wxString *) &_result_ref;
9759 }
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 {
9764 #if wxUSE_UNICODE
9765 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9766 #else
9767 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9768 #endif
9769 }
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9777 PyObject *resultobj = 0;
9778 wxFSFile *arg1 = (wxFSFile *) 0 ;
9779 wxString *result = 0 ;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9789 }
9790 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 {
9794 wxString const &_result_ref = (arg1)->GetLocation();
9795 result = (wxString *) &_result_ref;
9796 }
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 {
9801 #if wxUSE_UNICODE
9802 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9803 #else
9804 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9805 #endif
9806 }
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9814 PyObject *resultobj = 0;
9815 wxFSFile *arg1 = (wxFSFile *) 0 ;
9816 wxString *result = 0 ;
9817 void *argp1 = 0 ;
9818 int res1 = 0 ;
9819 PyObject *swig_obj[1] ;
9820
9821 if (!args) SWIG_fail;
9822 swig_obj[0] = args;
9823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9824 if (!SWIG_IsOK(res1)) {
9825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9826 }
9827 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 {
9831 wxString const &_result_ref = (arg1)->GetAnchor();
9832 result = (wxString *) &_result_ref;
9833 }
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 {
9838 #if wxUSE_UNICODE
9839 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9840 #else
9841 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9842 #endif
9843 }
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9851 PyObject *resultobj = 0;
9852 wxFSFile *arg1 = (wxFSFile *) 0 ;
9853 wxDateTime result;
9854 void *argp1 = 0 ;
9855 int res1 = 0 ;
9856 PyObject *swig_obj[1] ;
9857
9858 if (!args) SWIG_fail;
9859 swig_obj[0] = args;
9860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9861 if (!SWIG_IsOK(res1)) {
9862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9863 }
9864 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (arg1)->GetModificationTime();
9868 wxPyEndAllowThreads(__tstate);
9869 if (PyErr_Occurred()) SWIG_fail;
9870 }
9871 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9872 return resultobj;
9873 fail:
9874 return NULL;
9875 }
9876
9877
9878 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9879 PyObject *obj;
9880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9881 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9882 return SWIG_Py_Void();
9883 }
9884
9885 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886 return SWIG_Python_InitShadowInstance(args);
9887 }
9888
9889 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *resultobj = 0;
9891 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 PyObject *swig_obj[1] ;
9895
9896 if (!args) SWIG_fail;
9897 swig_obj[0] = args;
9898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9901 }
9902 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 delete arg1;
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_Py_Void();
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *obj;
9919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9920 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9921 return SWIG_Py_Void();
9922 }
9923
9924 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9925 PyObject *resultobj = 0;
9926 wxPyFileSystemHandler *result = 0 ;
9927
9928 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj = 0;
9944 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9945 PyObject *arg2 = (PyObject *) 0 ;
9946 PyObject *arg3 = (PyObject *) 0 ;
9947 void *argp1 = 0 ;
9948 int res1 = 0 ;
9949 PyObject * obj0 = 0 ;
9950 PyObject * obj1 = 0 ;
9951 PyObject * obj2 = 0 ;
9952 char * kwnames[] = {
9953 (char *) "self",(char *) "self",(char *) "_class", NULL
9954 };
9955
9956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9958 if (!SWIG_IsOK(res1)) {
9959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9960 }
9961 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9962 arg2 = obj1;
9963 arg3 = obj2;
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 (arg1)->_setCallbackInfo(arg2,arg3);
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 resultobj = SWIG_Py_Void();
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj = 0;
9979 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9980 wxString *arg2 = 0 ;
9981 bool result;
9982 void *argp1 = 0 ;
9983 int res1 = 0 ;
9984 bool temp2 = false ;
9985 PyObject * obj0 = 0 ;
9986 PyObject * obj1 = 0 ;
9987 char * kwnames[] = {
9988 (char *) "self",(char *) "location", NULL
9989 };
9990
9991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9993 if (!SWIG_IsOK(res1)) {
9994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9995 }
9996 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9997 {
9998 arg2 = wxString_in_helper(obj1);
9999 if (arg2 == NULL) SWIG_fail;
10000 temp2 = true;
10001 }
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10010 }
10011 {
10012 if (temp2)
10013 delete arg2;
10014 }
10015 return resultobj;
10016 fail:
10017 {
10018 if (temp2)
10019 delete arg2;
10020 }
10021 return NULL;
10022 }
10023
10024
10025 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10026 PyObject *resultobj = 0;
10027 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10028 wxFileSystem *arg2 = 0 ;
10029 wxString *arg3 = 0 ;
10030 wxFSFile *result = 0 ;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 void *argp2 = 0 ;
10034 int res2 = 0 ;
10035 bool temp3 = false ;
10036 PyObject * obj0 = 0 ;
10037 PyObject * obj1 = 0 ;
10038 PyObject * obj2 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "self",(char *) "fs",(char *) "location", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10047 }
10048 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10050 if (!SWIG_IsOK(res2)) {
10051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10052 }
10053 if (!argp2) {
10054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10055 }
10056 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10057 {
10058 arg3 = wxString_in_helper(obj2);
10059 if (arg3 == NULL) SWIG_fail;
10060 temp3 = true;
10061 }
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10065 wxPyEndAllowThreads(__tstate);
10066 if (PyErr_Occurred()) SWIG_fail;
10067 }
10068 {
10069 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10070 }
10071 {
10072 if (temp3)
10073 delete arg3;
10074 }
10075 return resultobj;
10076 fail:
10077 {
10078 if (temp3)
10079 delete arg3;
10080 }
10081 return NULL;
10082 }
10083
10084
10085 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj = 0;
10087 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10088 wxString *arg2 = 0 ;
10089 int arg3 = (int) 0 ;
10090 wxString result;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 bool temp2 = false ;
10094 int val3 ;
10095 int ecode3 = 0 ;
10096 PyObject * obj0 = 0 ;
10097 PyObject * obj1 = 0 ;
10098 PyObject * obj2 = 0 ;
10099 char * kwnames[] = {
10100 (char *) "self",(char *) "spec",(char *) "flags", NULL
10101 };
10102
10103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10105 if (!SWIG_IsOK(res1)) {
10106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10107 }
10108 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10109 {
10110 arg2 = wxString_in_helper(obj1);
10111 if (arg2 == NULL) SWIG_fail;
10112 temp2 = true;
10113 }
10114 if (obj2) {
10115 ecode3 = SWIG_AsVal_int(obj2, &val3);
10116 if (!SWIG_IsOK(ecode3)) {
10117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10118 }
10119 arg3 = static_cast< int >(val3);
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
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_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10149 PyObject *resultobj = 0;
10150 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10151 wxString result;
10152 void *argp1 = 0 ;
10153 int res1 = 0 ;
10154 PyObject *swig_obj[1] ;
10155
10156 if (!args) SWIG_fail;
10157 swig_obj[0] = args;
10158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10159 if (!SWIG_IsOK(res1)) {
10160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10161 }
10162 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10163 {
10164 PyThreadState* __tstate = wxPyBeginAllowThreads();
10165 result = (arg1)->FindNext();
10166 wxPyEndAllowThreads(__tstate);
10167 if (PyErr_Occurred()) SWIG_fail;
10168 }
10169 {
10170 #if wxUSE_UNICODE
10171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10172 #else
10173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10174 #endif
10175 }
10176 return resultobj;
10177 fail:
10178 return NULL;
10179 }
10180
10181
10182 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj = 0;
10184 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10185 wxString *arg2 = 0 ;
10186 wxString result;
10187 void *argp1 = 0 ;
10188 int res1 = 0 ;
10189 bool temp2 = false ;
10190 PyObject * obj0 = 0 ;
10191 PyObject * obj1 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "location", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10202 {
10203 arg2 = wxString_in_helper(obj1);
10204 if (arg2 == NULL) SWIG_fail;
10205 temp2 = true;
10206 }
10207 {
10208 PyThreadState* __tstate = wxPyBeginAllowThreads();
10209 result = (arg1)->GetProtocol((wxString const &)*arg2);
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 {
10214 #if wxUSE_UNICODE
10215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10216 #else
10217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10218 #endif
10219 }
10220 {
10221 if (temp2)
10222 delete arg2;
10223 }
10224 return resultobj;
10225 fail:
10226 {
10227 if (temp2)
10228 delete arg2;
10229 }
10230 return NULL;
10231 }
10232
10233
10234 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj = 0;
10236 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10237 wxString *arg2 = 0 ;
10238 wxString result;
10239 void *argp1 = 0 ;
10240 int res1 = 0 ;
10241 bool temp2 = false ;
10242 PyObject * obj0 = 0 ;
10243 PyObject * obj1 = 0 ;
10244 char * kwnames[] = {
10245 (char *) "self",(char *) "location", NULL
10246 };
10247
10248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10252 }
10253 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10254 {
10255 arg2 = wxString_in_helper(obj1);
10256 if (arg2 == NULL) SWIG_fail;
10257 temp2 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 {
10266 #if wxUSE_UNICODE
10267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10268 #else
10269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10270 #endif
10271 }
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return resultobj;
10277 fail:
10278 {
10279 if (temp2)
10280 delete arg2;
10281 }
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10289 wxString *arg2 = 0 ;
10290 wxString result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 bool temp2 = false ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "location", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10304 }
10305 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10306 {
10307 arg2 = wxString_in_helper(obj1);
10308 if (arg2 == NULL) SWIG_fail;
10309 temp2 = true;
10310 }
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 result = (arg1)->GetAnchor((wxString const &)*arg2);
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 {
10318 #if wxUSE_UNICODE
10319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10320 #else
10321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10322 #endif
10323 }
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj = 0;
10340 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10341 wxString *arg2 = 0 ;
10342 wxString result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 bool temp2 = false ;
10346 PyObject * obj0 = 0 ;
10347 PyObject * obj1 = 0 ;
10348 char * kwnames[] = {
10349 (char *) "self",(char *) "location", NULL
10350 };
10351
10352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10354 if (!SWIG_IsOK(res1)) {
10355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10356 }
10357 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10358 {
10359 arg2 = wxString_in_helper(obj1);
10360 if (arg2 == NULL) SWIG_fail;
10361 temp2 = true;
10362 }
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 {
10370 #if wxUSE_UNICODE
10371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10372 #else
10373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10374 #endif
10375 }
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return resultobj;
10381 fail:
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return NULL;
10387 }
10388
10389
10390 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj = 0;
10392 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10393 wxString *arg2 = 0 ;
10394 wxString result;
10395 void *argp1 = 0 ;
10396 int res1 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char * kwnames[] = {
10401 (char *) "self",(char *) "location", NULL
10402 };
10403
10404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10408 }
10409 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10410 {
10411 arg2 = wxString_in_helper(obj1);
10412 if (arg2 == NULL) SWIG_fail;
10413 temp2 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 #if wxUSE_UNICODE
10423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10424 #else
10425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10426 #endif
10427 }
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return resultobj;
10433 fail:
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10443 PyObject *obj;
10444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10445 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10446 return SWIG_Py_Void();
10447 }
10448
10449 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10450 return SWIG_Python_InitShadowInstance(args);
10451 }
10452
10453 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 PyObject *resultobj = 0;
10455 wxFileSystem *result = 0 ;
10456
10457 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 result = (wxFileSystem *)new wxFileSystem();
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 {
10465 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10466 }
10467 return resultobj;
10468 fail:
10469 return NULL;
10470 }
10471
10472
10473 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10476 void *argp1 = 0 ;
10477 int res1 = 0 ;
10478 PyObject *swig_obj[1] ;
10479
10480 if (!args) SWIG_fail;
10481 swig_obj[0] = args;
10482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10483 if (!SWIG_IsOK(res1)) {
10484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10485 }
10486 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10487 {
10488 PyThreadState* __tstate = wxPyBeginAllowThreads();
10489 delete arg1;
10490
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 resultobj = SWIG_Py_Void();
10495 return resultobj;
10496 fail:
10497 return NULL;
10498 }
10499
10500
10501 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10502 PyObject *resultobj = 0;
10503 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10504 wxString *arg2 = 0 ;
10505 bool arg3 = (bool) false ;
10506 void *argp1 = 0 ;
10507 int res1 = 0 ;
10508 bool temp2 = false ;
10509 bool val3 ;
10510 int ecode3 = 0 ;
10511 PyObject * obj0 = 0 ;
10512 PyObject * obj1 = 0 ;
10513 PyObject * obj2 = 0 ;
10514 char * kwnames[] = {
10515 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10516 };
10517
10518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10520 if (!SWIG_IsOK(res1)) {
10521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10522 }
10523 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10524 {
10525 arg2 = wxString_in_helper(obj1);
10526 if (arg2 == NULL) SWIG_fail;
10527 temp2 = true;
10528 }
10529 if (obj2) {
10530 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10531 if (!SWIG_IsOK(ecode3)) {
10532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10533 }
10534 arg3 = static_cast< bool >(val3);
10535 }
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 resultobj = SWIG_Py_Void();
10543 {
10544 if (temp2)
10545 delete arg2;
10546 }
10547 return resultobj;
10548 fail:
10549 {
10550 if (temp2)
10551 delete arg2;
10552 }
10553 return NULL;
10554 }
10555
10556
10557 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10558 PyObject *resultobj = 0;
10559 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10560 wxString result;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 PyObject *swig_obj[1] ;
10564
10565 if (!args) SWIG_fail;
10566 swig_obj[0] = args;
10567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10568 if (!SWIG_IsOK(res1)) {
10569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10570 }
10571 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10572 {
10573 PyThreadState* __tstate = wxPyBeginAllowThreads();
10574 result = (arg1)->GetPath();
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 {
10579 #if wxUSE_UNICODE
10580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10581 #else
10582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10583 #endif
10584 }
10585 return resultobj;
10586 fail:
10587 return NULL;
10588 }
10589
10590
10591 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj = 0;
10593 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10594 wxString *arg2 = 0 ;
10595 wxFSFile *result = 0 ;
10596 void *argp1 = 0 ;
10597 int res1 = 0 ;
10598 bool temp2 = false ;
10599 PyObject * obj0 = 0 ;
10600 PyObject * obj1 = 0 ;
10601 char * kwnames[] = {
10602 (char *) "self",(char *) "location", NULL
10603 };
10604
10605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10607 if (!SWIG_IsOK(res1)) {
10608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10609 }
10610 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10611 {
10612 arg2 = wxString_in_helper(obj1);
10613 if (arg2 == NULL) SWIG_fail;
10614 temp2 = true;
10615 }
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 {
10623 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10624 }
10625 {
10626 if (temp2)
10627 delete arg2;
10628 }
10629 return resultobj;
10630 fail:
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10642 wxString *arg2 = 0 ;
10643 int arg3 = (int) 0 ;
10644 wxString result;
10645 void *argp1 = 0 ;
10646 int res1 = 0 ;
10647 bool temp2 = false ;
10648 int val3 ;
10649 int ecode3 = 0 ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 PyObject * obj2 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "spec",(char *) "flags", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10661 }
10662 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10663 {
10664 arg2 = wxString_in_helper(obj1);
10665 if (arg2 == NULL) SWIG_fail;
10666 temp2 = true;
10667 }
10668 if (obj2) {
10669 ecode3 = SWIG_AsVal_int(obj2, &val3);
10670 if (!SWIG_IsOK(ecode3)) {
10671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10672 }
10673 arg3 = static_cast< int >(val3);
10674 }
10675 {
10676 PyThreadState* __tstate = wxPyBeginAllowThreads();
10677 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10678 wxPyEndAllowThreads(__tstate);
10679 if (PyErr_Occurred()) SWIG_fail;
10680 }
10681 {
10682 #if wxUSE_UNICODE
10683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10684 #else
10685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10686 #endif
10687 }
10688 {
10689 if (temp2)
10690 delete arg2;
10691 }
10692 return resultobj;
10693 fail:
10694 {
10695 if (temp2)
10696 delete arg2;
10697 }
10698 return NULL;
10699 }
10700
10701
10702 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10703 PyObject *resultobj = 0;
10704 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10705 wxString result;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 PyObject *swig_obj[1] ;
10709
10710 if (!args) SWIG_fail;
10711 swig_obj[0] = args;
10712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10713 if (!SWIG_IsOK(res1)) {
10714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10715 }
10716 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (arg1)->FindNext();
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 {
10724 #if wxUSE_UNICODE
10725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10726 #else
10727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10728 #endif
10729 }
10730 return resultobj;
10731 fail:
10732 return NULL;
10733 }
10734
10735
10736 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj = 0;
10738 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10739 int res1 = 0 ;
10740 PyObject * obj0 = 0 ;
10741 char * kwnames[] = {
10742 (char *) "handler", NULL
10743 };
10744
10745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10746 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10747 if (!SWIG_IsOK(res1)) {
10748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10749 }
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 wxFileSystem::AddHandler(arg1);
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10764 PyObject *resultobj = 0;
10765
10766 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 wxFileSystem::CleanUpHandlers();
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = SWIG_Py_Void();
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj = 0;
10782 wxString *arg1 = 0 ;
10783 wxString result;
10784 bool temp1 = false ;
10785 PyObject * obj0 = 0 ;
10786 char * kwnames[] = {
10787 (char *) "filename", NULL
10788 };
10789
10790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10791 {
10792 arg1 = wxString_in_helper(obj0);
10793 if (arg1 == NULL) SWIG_fail;
10794 temp1 = true;
10795 }
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 {
10803 #if wxUSE_UNICODE
10804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10805 #else
10806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10807 #endif
10808 }
10809 {
10810 if (temp1)
10811 delete arg1;
10812 }
10813 return resultobj;
10814 fail:
10815 {
10816 if (temp1)
10817 delete arg1;
10818 }
10819 return NULL;
10820 }
10821
10822
10823 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10824 PyObject *resultobj = 0;
10825 wxString *arg1 = 0 ;
10826 wxString result;
10827 bool temp1 = false ;
10828 PyObject * obj0 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "url", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10834 {
10835 arg1 = wxString_in_helper(obj0);
10836 if (arg1 == NULL) SWIG_fail;
10837 temp1 = true;
10838 }
10839 {
10840 PyThreadState* __tstate = wxPyBeginAllowThreads();
10841 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10842 wxPyEndAllowThreads(__tstate);
10843 if (PyErr_Occurred()) SWIG_fail;
10844 }
10845 {
10846 #if wxUSE_UNICODE
10847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10848 #else
10849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10850 #endif
10851 }
10852 {
10853 if (temp1)
10854 delete arg1;
10855 }
10856 return resultobj;
10857 fail:
10858 {
10859 if (temp1)
10860 delete arg1;
10861 }
10862 return NULL;
10863 }
10864
10865
10866 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10867 PyObject *obj;
10868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10869 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10870 return SWIG_Py_Void();
10871 }
10872
10873 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874 return SWIG_Python_InitShadowInstance(args);
10875 }
10876
10877 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *resultobj = 0;
10879 wxInternetFSHandler *result = 0 ;
10880
10881 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10882 {
10883 PyThreadState* __tstate = wxPyBeginAllowThreads();
10884 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj = 0;
10897 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10898 wxString *arg2 = 0 ;
10899 bool result;
10900 void *argp1 = 0 ;
10901 int res1 = 0 ;
10902 bool temp2 = false ;
10903 PyObject * obj0 = 0 ;
10904 PyObject * obj1 = 0 ;
10905 char * kwnames[] = {
10906 (char *) "self",(char *) "location", NULL
10907 };
10908
10909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10911 if (!SWIG_IsOK(res1)) {
10912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10913 }
10914 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10915 {
10916 arg2 = wxString_in_helper(obj1);
10917 if (arg2 == NULL) SWIG_fail;
10918 temp2 = true;
10919 }
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 {
10927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10928 }
10929 {
10930 if (temp2)
10931 delete arg2;
10932 }
10933 return resultobj;
10934 fail:
10935 {
10936 if (temp2)
10937 delete arg2;
10938 }
10939 return NULL;
10940 }
10941
10942
10943 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj = 0;
10945 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10946 wxFileSystem *arg2 = 0 ;
10947 wxString *arg3 = 0 ;
10948 wxFSFile *result = 0 ;
10949 void *argp1 = 0 ;
10950 int res1 = 0 ;
10951 void *argp2 = 0 ;
10952 int res2 = 0 ;
10953 bool temp3 = false ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 PyObject * obj2 = 0 ;
10957 char * kwnames[] = {
10958 (char *) "self",(char *) "fs",(char *) "location", NULL
10959 };
10960
10961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10965 }
10966 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10967 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10968 if (!SWIG_IsOK(res2)) {
10969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10970 }
10971 if (!argp2) {
10972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10973 }
10974 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10975 {
10976 arg3 = wxString_in_helper(obj2);
10977 if (arg3 == NULL) SWIG_fail;
10978 temp3 = true;
10979 }
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 {
10987 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10988 }
10989 {
10990 if (temp3)
10991 delete arg3;
10992 }
10993 return resultobj;
10994 fail:
10995 {
10996 if (temp3)
10997 delete arg3;
10998 }
10999 return NULL;
11000 }
11001
11002
11003 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *obj;
11005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11006 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11007 return SWIG_Py_Void();
11008 }
11009
11010 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11011 return SWIG_Python_InitShadowInstance(args);
11012 }
11013
11014 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *resultobj = 0;
11016 wxZipFSHandler *result = 0 ;
11017
11018 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 result = (wxZipFSHandler *)new wxZipFSHandler();
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj = 0;
11034 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11035 wxString *arg2 = 0 ;
11036 bool result;
11037 void *argp1 = 0 ;
11038 int res1 = 0 ;
11039 bool temp2 = false ;
11040 PyObject * obj0 = 0 ;
11041 PyObject * obj1 = 0 ;
11042 char * kwnames[] = {
11043 (char *) "self",(char *) "location", NULL
11044 };
11045
11046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11048 if (!SWIG_IsOK(res1)) {
11049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11050 }
11051 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11052 {
11053 arg2 = wxString_in_helper(obj1);
11054 if (arg2 == NULL) SWIG_fail;
11055 temp2 = true;
11056 }
11057 {
11058 PyThreadState* __tstate = wxPyBeginAllowThreads();
11059 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 {
11064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11065 }
11066 {
11067 if (temp2)
11068 delete arg2;
11069 }
11070 return resultobj;
11071 fail:
11072 {
11073 if (temp2)
11074 delete arg2;
11075 }
11076 return NULL;
11077 }
11078
11079
11080 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11081 PyObject *resultobj = 0;
11082 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11083 wxFileSystem *arg2 = 0 ;
11084 wxString *arg3 = 0 ;
11085 wxFSFile *result = 0 ;
11086 void *argp1 = 0 ;
11087 int res1 = 0 ;
11088 void *argp2 = 0 ;
11089 int res2 = 0 ;
11090 bool temp3 = false ;
11091 PyObject * obj0 = 0 ;
11092 PyObject * obj1 = 0 ;
11093 PyObject * obj2 = 0 ;
11094 char * kwnames[] = {
11095 (char *) "self",(char *) "fs",(char *) "location", NULL
11096 };
11097
11098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11102 }
11103 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11105 if (!SWIG_IsOK(res2)) {
11106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11107 }
11108 if (!argp2) {
11109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11110 }
11111 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11112 {
11113 arg3 = wxString_in_helper(obj2);
11114 if (arg3 == NULL) SWIG_fail;
11115 temp3 = true;
11116 }
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 {
11124 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11125 }
11126 {
11127 if (temp3)
11128 delete arg3;
11129 }
11130 return resultobj;
11131 fail:
11132 {
11133 if (temp3)
11134 delete arg3;
11135 }
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj = 0;
11142 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11143 wxString *arg2 = 0 ;
11144 int arg3 = (int) 0 ;
11145 wxString result;
11146 void *argp1 = 0 ;
11147 int res1 = 0 ;
11148 bool temp2 = false ;
11149 int val3 ;
11150 int ecode3 = 0 ;
11151 PyObject * obj0 = 0 ;
11152 PyObject * obj1 = 0 ;
11153 PyObject * obj2 = 0 ;
11154 char * kwnames[] = {
11155 (char *) "self",(char *) "spec",(char *) "flags", NULL
11156 };
11157
11158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11160 if (!SWIG_IsOK(res1)) {
11161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11162 }
11163 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11164 {
11165 arg2 = wxString_in_helper(obj1);
11166 if (arg2 == NULL) SWIG_fail;
11167 temp2 = true;
11168 }
11169 if (obj2) {
11170 ecode3 = SWIG_AsVal_int(obj2, &val3);
11171 if (!SWIG_IsOK(ecode3)) {
11172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11173 }
11174 arg3 = static_cast< int >(val3);
11175 }
11176 {
11177 PyThreadState* __tstate = wxPyBeginAllowThreads();
11178 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11179 wxPyEndAllowThreads(__tstate);
11180 if (PyErr_Occurred()) SWIG_fail;
11181 }
11182 {
11183 #if wxUSE_UNICODE
11184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11185 #else
11186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11187 #endif
11188 }
11189 {
11190 if (temp2)
11191 delete arg2;
11192 }
11193 return resultobj;
11194 fail:
11195 {
11196 if (temp2)
11197 delete arg2;
11198 }
11199 return NULL;
11200 }
11201
11202
11203 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11204 PyObject *resultobj = 0;
11205 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11206 wxString result;
11207 void *argp1 = 0 ;
11208 int res1 = 0 ;
11209 PyObject *swig_obj[1] ;
11210
11211 if (!args) SWIG_fail;
11212 swig_obj[0] = args;
11213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11214 if (!SWIG_IsOK(res1)) {
11215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11216 }
11217 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 result = (arg1)->FindNext();
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 {
11225 #if wxUSE_UNICODE
11226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11227 #else
11228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11229 #endif
11230 }
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11238 PyObject *obj;
11239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11240 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11241 return SWIG_Py_Void();
11242 }
11243
11244 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11245 return SWIG_Python_InitShadowInstance(args);
11246 }
11247
11248 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxString *arg1 = 0 ;
11251 wxImage *arg2 = 0 ;
11252 long arg3 ;
11253 bool temp1 = false ;
11254 void *argp2 = 0 ;
11255 int res2 = 0 ;
11256 long val3 ;
11257 int ecode3 = 0 ;
11258 PyObject * obj0 = 0 ;
11259 PyObject * obj1 = 0 ;
11260 PyObject * obj2 = 0 ;
11261 char * kwnames[] = {
11262 (char *) "filename",(char *) "image",(char *) "type", NULL
11263 };
11264
11265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11266 {
11267 arg1 = wxString_in_helper(obj0);
11268 if (arg1 == NULL) SWIG_fail;
11269 temp1 = true;
11270 }
11271 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11272 if (!SWIG_IsOK(res2)) {
11273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11274 }
11275 if (!argp2) {
11276 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11277 }
11278 arg2 = reinterpret_cast< wxImage * >(argp2);
11279 ecode3 = SWIG_AsVal_long(obj2, &val3);
11280 if (!SWIG_IsOK(ecode3)) {
11281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11282 }
11283 arg3 = static_cast< long >(val3);
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 resultobj = SWIG_Py_Void();
11291 {
11292 if (temp1)
11293 delete arg1;
11294 }
11295 return resultobj;
11296 fail:
11297 {
11298 if (temp1)
11299 delete arg1;
11300 }
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11306 PyObject *resultobj = 0;
11307 wxString *arg1 = 0 ;
11308 wxBitmap *arg2 = 0 ;
11309 long arg3 ;
11310 bool temp1 = false ;
11311 void *argp2 = 0 ;
11312 int res2 = 0 ;
11313 long val3 ;
11314 int ecode3 = 0 ;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 PyObject * obj2 = 0 ;
11318 char * kwnames[] = {
11319 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11320 };
11321
11322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11323 {
11324 arg1 = wxString_in_helper(obj0);
11325 if (arg1 == NULL) SWIG_fail;
11326 temp1 = true;
11327 }
11328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11329 if (!SWIG_IsOK(res2)) {
11330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11331 }
11332 if (!argp2) {
11333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11334 }
11335 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11336 ecode3 = SWIG_AsVal_long(obj2, &val3);
11337 if (!SWIG_IsOK(ecode3)) {
11338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11339 }
11340 arg3 = static_cast< long >(val3);
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11344 wxPyEndAllowThreads(__tstate);
11345 if (PyErr_Occurred()) SWIG_fail;
11346 }
11347 resultobj = SWIG_Py_Void();
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return resultobj;
11353 fail:
11354 {
11355 if (temp1)
11356 delete arg1;
11357 }
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj = 0;
11364 wxString *arg1 = 0 ;
11365 PyObject *arg2 = (PyObject *) 0 ;
11366 bool temp1 = false ;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 char * kwnames[] = {
11370 (char *) "filename",(char *) "data", NULL
11371 };
11372
11373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11374 {
11375 arg1 = wxString_in_helper(obj0);
11376 if (arg1 == NULL) SWIG_fail;
11377 temp1 = true;
11378 }
11379 arg2 = obj1;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 resultobj = SWIG_Py_Void();
11387 {
11388 if (temp1)
11389 delete arg1;
11390 }
11391 return resultobj;
11392 fail:
11393 {
11394 if (temp1)
11395 delete arg1;
11396 }
11397 return NULL;
11398 }
11399
11400
11401 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11402 PyObject *resultobj = 0;
11403 wxMemoryFSHandler *result = 0 ;
11404
11405 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11420 PyObject *resultobj = 0;
11421 wxString *arg1 = 0 ;
11422 bool temp1 = false ;
11423 PyObject * obj0 = 0 ;
11424 char * kwnames[] = {
11425 (char *) "filename", NULL
11426 };
11427
11428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11429 {
11430 arg1 = wxString_in_helper(obj0);
11431 if (arg1 == NULL) SWIG_fail;
11432 temp1 = true;
11433 }
11434 {
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 resultobj = SWIG_Py_Void();
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return resultobj;
11446 fail:
11447 {
11448 if (temp1)
11449 delete arg1;
11450 }
11451 return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj = 0;
11457 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11458 wxString *arg2 = 0 ;
11459 bool result;
11460 void *argp1 = 0 ;
11461 int res1 = 0 ;
11462 bool temp2 = false ;
11463 PyObject * obj0 = 0 ;
11464 PyObject * obj1 = 0 ;
11465 char * kwnames[] = {
11466 (char *) "self",(char *) "location", NULL
11467 };
11468
11469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11471 if (!SWIG_IsOK(res1)) {
11472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11473 }
11474 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11475 {
11476 arg2 = wxString_in_helper(obj1);
11477 if (arg2 == NULL) SWIG_fail;
11478 temp2 = true;
11479 }
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11488 }
11489 {
11490 if (temp2)
11491 delete arg2;
11492 }
11493 return resultobj;
11494 fail:
11495 {
11496 if (temp2)
11497 delete arg2;
11498 }
11499 return NULL;
11500 }
11501
11502
11503 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj = 0;
11505 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11506 wxFileSystem *arg2 = 0 ;
11507 wxString *arg3 = 0 ;
11508 wxFSFile *result = 0 ;
11509 void *argp1 = 0 ;
11510 int res1 = 0 ;
11511 void *argp2 = 0 ;
11512 int res2 = 0 ;
11513 bool temp3 = false ;
11514 PyObject * obj0 = 0 ;
11515 PyObject * obj1 = 0 ;
11516 PyObject * obj2 = 0 ;
11517 char * kwnames[] = {
11518 (char *) "self",(char *) "fs",(char *) "location", NULL
11519 };
11520
11521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11523 if (!SWIG_IsOK(res1)) {
11524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11525 }
11526 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11527 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11528 if (!SWIG_IsOK(res2)) {
11529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11530 }
11531 if (!argp2) {
11532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11533 }
11534 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11535 {
11536 arg3 = wxString_in_helper(obj2);
11537 if (arg3 == NULL) SWIG_fail;
11538 temp3 = true;
11539 }
11540 {
11541 PyThreadState* __tstate = wxPyBeginAllowThreads();
11542 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 {
11547 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11548 }
11549 {
11550 if (temp3)
11551 delete arg3;
11552 }
11553 return resultobj;
11554 fail:
11555 {
11556 if (temp3)
11557 delete arg3;
11558 }
11559 return NULL;
11560 }
11561
11562
11563 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj = 0;
11565 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11566 wxString *arg2 = 0 ;
11567 int arg3 = (int) 0 ;
11568 wxString result;
11569 void *argp1 = 0 ;
11570 int res1 = 0 ;
11571 bool temp2 = false ;
11572 int val3 ;
11573 int ecode3 = 0 ;
11574 PyObject * obj0 = 0 ;
11575 PyObject * obj1 = 0 ;
11576 PyObject * obj2 = 0 ;
11577 char * kwnames[] = {
11578 (char *) "self",(char *) "spec",(char *) "flags", NULL
11579 };
11580
11581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11585 }
11586 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11587 {
11588 arg2 = wxString_in_helper(obj1);
11589 if (arg2 == NULL) SWIG_fail;
11590 temp2 = true;
11591 }
11592 if (obj2) {
11593 ecode3 = SWIG_AsVal_int(obj2, &val3);
11594 if (!SWIG_IsOK(ecode3)) {
11595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11596 }
11597 arg3 = static_cast< int >(val3);
11598 }
11599 {
11600 PyThreadState* __tstate = wxPyBeginAllowThreads();
11601 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11602 wxPyEndAllowThreads(__tstate);
11603 if (PyErr_Occurred()) SWIG_fail;
11604 }
11605 {
11606 #if wxUSE_UNICODE
11607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11608 #else
11609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11610 #endif
11611 }
11612 {
11613 if (temp2)
11614 delete arg2;
11615 }
11616 return resultobj;
11617 fail:
11618 {
11619 if (temp2)
11620 delete arg2;
11621 }
11622 return NULL;
11623 }
11624
11625
11626 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11627 PyObject *resultobj = 0;
11628 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11629 wxString result;
11630 void *argp1 = 0 ;
11631 int res1 = 0 ;
11632 PyObject *swig_obj[1] ;
11633
11634 if (!args) SWIG_fail;
11635 swig_obj[0] = args;
11636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11637 if (!SWIG_IsOK(res1)) {
11638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11639 }
11640 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11641 {
11642 PyThreadState* __tstate = wxPyBeginAllowThreads();
11643 result = (arg1)->FindNext();
11644 wxPyEndAllowThreads(__tstate);
11645 if (PyErr_Occurred()) SWIG_fail;
11646 }
11647 {
11648 #if wxUSE_UNICODE
11649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11650 #else
11651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11652 #endif
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661 PyObject *obj;
11662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11663 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11664 return SWIG_Py_Void();
11665 }
11666
11667 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 return SWIG_Python_InitShadowInstance(args);
11669 }
11670
11671 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 PyObject *resultobj = 0;
11673 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11674 wxString result;
11675 void *argp1 = 0 ;
11676 int res1 = 0 ;
11677 PyObject *swig_obj[1] ;
11678
11679 if (!args) SWIG_fail;
11680 swig_obj[0] = args;
11681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11682 if (!SWIG_IsOK(res1)) {
11683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11684 }
11685 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11686 {
11687 PyThreadState* __tstate = wxPyBeginAllowThreads();
11688 result = (arg1)->GetName();
11689 wxPyEndAllowThreads(__tstate);
11690 if (PyErr_Occurred()) SWIG_fail;
11691 }
11692 {
11693 #if wxUSE_UNICODE
11694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11695 #else
11696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11697 #endif
11698 }
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11706 PyObject *resultobj = 0;
11707 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11708 wxString result;
11709 void *argp1 = 0 ;
11710 int res1 = 0 ;
11711 PyObject *swig_obj[1] ;
11712
11713 if (!args) SWIG_fail;
11714 swig_obj[0] = args;
11715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11716 if (!SWIG_IsOK(res1)) {
11717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11718 }
11719 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (arg1)->GetExtension();
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 {
11727 #if wxUSE_UNICODE
11728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11729 #else
11730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11731 #endif
11732 }
11733 return resultobj;
11734 fail:
11735 return NULL;
11736 }
11737
11738
11739 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11740 PyObject *resultobj = 0;
11741 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11742 long result;
11743 void *argp1 = 0 ;
11744 int res1 = 0 ;
11745 PyObject *swig_obj[1] ;
11746
11747 if (!args) SWIG_fail;
11748 swig_obj[0] = args;
11749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11750 if (!SWIG_IsOK(res1)) {
11751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11752 }
11753 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11754 {
11755 PyThreadState* __tstate = wxPyBeginAllowThreads();
11756 result = (long)(arg1)->GetType();
11757 wxPyEndAllowThreads(__tstate);
11758 if (PyErr_Occurred()) SWIG_fail;
11759 }
11760 resultobj = SWIG_From_long(static_cast< long >(result));
11761 return resultobj;
11762 fail:
11763 return NULL;
11764 }
11765
11766
11767 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11768 PyObject *resultobj = 0;
11769 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11770 wxString result;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 PyObject *swig_obj[1] ;
11774
11775 if (!args) SWIG_fail;
11776 swig_obj[0] = args;
11777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11778 if (!SWIG_IsOK(res1)) {
11779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11780 }
11781 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (arg1)->GetMimeType();
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 #if wxUSE_UNICODE
11790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11791 #else
11792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11793 #endif
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj = 0;
11803 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11804 wxString *arg2 = 0 ;
11805 bool result;
11806 void *argp1 = 0 ;
11807 int res1 = 0 ;
11808 bool temp2 = false ;
11809 PyObject * obj0 = 0 ;
11810 PyObject * obj1 = 0 ;
11811 char * kwnames[] = {
11812 (char *) "self",(char *) "name", NULL
11813 };
11814
11815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11819 }
11820 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11821 {
11822 arg2 = wxString_in_helper(obj1);
11823 if (arg2 == NULL) SWIG_fail;
11824 temp2 = true;
11825 }
11826 {
11827 PyThreadState* __tstate = wxPyBeginAllowThreads();
11828 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11829 wxPyEndAllowThreads(__tstate);
11830 if (PyErr_Occurred()) SWIG_fail;
11831 }
11832 {
11833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11834 }
11835 {
11836 if (temp2)
11837 delete arg2;
11838 }
11839 return resultobj;
11840 fail:
11841 {
11842 if (temp2)
11843 delete arg2;
11844 }
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11850 PyObject *resultobj = 0;
11851 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11852 wxInputStream *arg2 = 0 ;
11853 bool result;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 wxPyInputStream *temp2 ;
11857 bool created2 ;
11858 PyObject * obj0 = 0 ;
11859 PyObject * obj1 = 0 ;
11860 char * kwnames[] = {
11861 (char *) "self",(char *) "stream", NULL
11862 };
11863
11864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11868 }
11869 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11870 {
11871 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11872 arg2 = temp2->m_wxis;
11873 created2 = false;
11874 } else {
11875 PyErr_Clear(); // clear the failure of the wxPyConvert above
11876 arg2 = wxPyCBInputStream_create(obj1, false);
11877 if (arg2 == NULL) {
11878 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11879 SWIG_fail;
11880 }
11881 created2 = true;
11882 }
11883 }
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (bool)(arg1)->CanRead(*arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 {
11891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11892 }
11893 {
11894 if (created2) delete arg2;
11895 }
11896 return resultobj;
11897 fail:
11898 {
11899 if (created2) delete arg2;
11900 }
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj = 0;
11907 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11908 wxString *arg2 = 0 ;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 bool temp2 = false ;
11912 PyObject * obj0 = 0 ;
11913 PyObject * obj1 = 0 ;
11914 char * kwnames[] = {
11915 (char *) "self",(char *) "name", NULL
11916 };
11917
11918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11920 if (!SWIG_IsOK(res1)) {
11921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11922 }
11923 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11924 {
11925 arg2 = wxString_in_helper(obj1);
11926 if (arg2 == NULL) SWIG_fail;
11927 temp2 = true;
11928 }
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 (arg1)->SetName((wxString const &)*arg2);
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 resultobj = SWIG_Py_Void();
11936 {
11937 if (temp2)
11938 delete arg2;
11939 }
11940 return resultobj;
11941 fail:
11942 {
11943 if (temp2)
11944 delete arg2;
11945 }
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 wxString *arg2 = 0 ;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 bool temp2 = false ;
11957 PyObject * obj0 = 0 ;
11958 PyObject * obj1 = 0 ;
11959 char * kwnames[] = {
11960 (char *) "self",(char *) "extension", NULL
11961 };
11962
11963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11965 if (!SWIG_IsOK(res1)) {
11966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11967 }
11968 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11969 {
11970 arg2 = wxString_in_helper(obj1);
11971 if (arg2 == NULL) SWIG_fail;
11972 temp2 = true;
11973 }
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 (arg1)->SetExtension((wxString const &)*arg2);
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 resultobj = SWIG_Py_Void();
11981 {
11982 if (temp2)
11983 delete arg2;
11984 }
11985 return resultobj;
11986 fail:
11987 {
11988 if (temp2)
11989 delete arg2;
11990 }
11991 return NULL;
11992 }
11993
11994
11995 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj = 0;
11997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11998 long arg2 ;
11999 void *argp1 = 0 ;
12000 int res1 = 0 ;
12001 long val2 ;
12002 int ecode2 = 0 ;
12003 PyObject * obj0 = 0 ;
12004 PyObject * obj1 = 0 ;
12005 char * kwnames[] = {
12006 (char *) "self",(char *) "type", NULL
12007 };
12008
12009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12013 }
12014 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12015 ecode2 = SWIG_AsVal_long(obj1, &val2);
12016 if (!SWIG_IsOK(ecode2)) {
12017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12018 }
12019 arg2 = static_cast< long >(val2);
12020 {
12021 PyThreadState* __tstate = wxPyBeginAllowThreads();
12022 (arg1)->SetType(arg2);
12023 wxPyEndAllowThreads(__tstate);
12024 if (PyErr_Occurred()) SWIG_fail;
12025 }
12026 resultobj = SWIG_Py_Void();
12027 return resultobj;
12028 fail:
12029 return NULL;
12030 }
12031
12032
12033 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12034 PyObject *resultobj = 0;
12035 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12036 wxString *arg2 = 0 ;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 bool temp2 = false ;
12040 PyObject * obj0 = 0 ;
12041 PyObject * obj1 = 0 ;
12042 char * kwnames[] = {
12043 (char *) "self",(char *) "mimetype", NULL
12044 };
12045
12046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12048 if (!SWIG_IsOK(res1)) {
12049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12050 }
12051 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12052 {
12053 arg2 = wxString_in_helper(obj1);
12054 if (arg2 == NULL) SWIG_fail;
12055 temp2 = true;
12056 }
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 (arg1)->SetMimeType((wxString const &)*arg2);
12060 wxPyEndAllowThreads(__tstate);
12061 if (PyErr_Occurred()) SWIG_fail;
12062 }
12063 resultobj = SWIG_Py_Void();
12064 {
12065 if (temp2)
12066 delete arg2;
12067 }
12068 return resultobj;
12069 fail:
12070 {
12071 if (temp2)
12072 delete arg2;
12073 }
12074 return NULL;
12075 }
12076
12077
12078 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12079 PyObject *obj;
12080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12081 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12082 return SWIG_Py_Void();
12083 }
12084
12085 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12086 PyObject *resultobj = 0;
12087 wxPyImageHandler *result = 0 ;
12088
12089 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (wxPyImageHandler *)new wxPyImageHandler();
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj = 0;
12105 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12106 PyObject *arg2 = (PyObject *) 0 ;
12107 void *argp1 = 0 ;
12108 int res1 = 0 ;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12111 char * kwnames[] = {
12112 (char *) "self",(char *) "self", NULL
12113 };
12114
12115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12119 }
12120 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12121 arg2 = obj1;
12122 {
12123 PyThreadState* __tstate = wxPyBeginAllowThreads();
12124 (arg1)->_SetSelf(arg2);
12125 wxPyEndAllowThreads(__tstate);
12126 if (PyErr_Occurred()) SWIG_fail;
12127 }
12128 resultobj = SWIG_Py_Void();
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12136 PyObject *obj;
12137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12138 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12139 return SWIG_Py_Void();
12140 }
12141
12142 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12143 return SWIG_Python_InitShadowInstance(args);
12144 }
12145
12146 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 PyObject *resultobj = 0;
12148 wxImageHistogram *result = 0 ;
12149
12150 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (wxImageHistogram *)new wxImageHistogram();
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj = 0;
12166 byte arg1 ;
12167 byte arg2 ;
12168 byte arg3 ;
12169 unsigned long result;
12170 unsigned char val1 ;
12171 int ecode1 = 0 ;
12172 unsigned char val2 ;
12173 int ecode2 = 0 ;
12174 unsigned char val3 ;
12175 int ecode3 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 char * kwnames[] = {
12180 (char *) "r",(char *) "g",(char *) "b", NULL
12181 };
12182
12183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12184 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12185 if (!SWIG_IsOK(ecode1)) {
12186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12187 }
12188 arg1 = static_cast< byte >(val1);
12189 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12190 if (!SWIG_IsOK(ecode2)) {
12191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12192 }
12193 arg2 = static_cast< byte >(val2);
12194 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12195 if (!SWIG_IsOK(ecode3)) {
12196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12197 }
12198 arg3 = static_cast< byte >(val3);
12199 {
12200 PyThreadState* __tstate = wxPyBeginAllowThreads();
12201 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12202 wxPyEndAllowThreads(__tstate);
12203 if (PyErr_Occurred()) SWIG_fail;
12204 }
12205 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12206 return resultobj;
12207 fail:
12208 return NULL;
12209 }
12210
12211
12212 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj = 0;
12214 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12215 byte *arg2 = (byte *) 0 ;
12216 byte *arg3 = (byte *) 0 ;
12217 byte *arg4 = (byte *) 0 ;
12218 byte arg5 = (byte) 1 ;
12219 byte arg6 = (byte) 0 ;
12220 byte arg7 = (byte) 0 ;
12221 bool result;
12222 void *argp1 = 0 ;
12223 int res1 = 0 ;
12224 byte temp2 ;
12225 int res2 = SWIG_TMPOBJ ;
12226 byte temp3 ;
12227 int res3 = SWIG_TMPOBJ ;
12228 byte temp4 ;
12229 int res4 = SWIG_TMPOBJ ;
12230 unsigned char val5 ;
12231 int ecode5 = 0 ;
12232 unsigned char val6 ;
12233 int ecode6 = 0 ;
12234 unsigned char val7 ;
12235 int ecode7 = 0 ;
12236 PyObject * obj0 = 0 ;
12237 PyObject * obj1 = 0 ;
12238 PyObject * obj2 = 0 ;
12239 PyObject * obj3 = 0 ;
12240 char * kwnames[] = {
12241 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12242 };
12243
12244 arg2 = &temp2;
12245 arg3 = &temp3;
12246 arg4 = &temp4;
12247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12249 if (!SWIG_IsOK(res1)) {
12250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12251 }
12252 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12253 if (obj1) {
12254 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12255 if (!SWIG_IsOK(ecode5)) {
12256 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12257 }
12258 arg5 = static_cast< byte >(val5);
12259 }
12260 if (obj2) {
12261 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12262 if (!SWIG_IsOK(ecode6)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12264 }
12265 arg6 = static_cast< byte >(val6);
12266 }
12267 if (obj3) {
12268 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12269 if (!SWIG_IsOK(ecode7)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12271 }
12272 arg7 = static_cast< byte >(val7);
12273 }
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 {
12281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12282 }
12283 if (SWIG_IsTmpObj(res2)) {
12284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12285 } else {
12286 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12288 }
12289 if (SWIG_IsTmpObj(res3)) {
12290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12291 } else {
12292 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12294 }
12295 if (SWIG_IsTmpObj(res4)) {
12296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12297 } else {
12298 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12300 }
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12308 PyObject *resultobj = 0;
12309 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12310 unsigned long arg2 ;
12311 unsigned long result;
12312 void *argp1 = 0 ;
12313 int res1 = 0 ;
12314 unsigned long val2 ;
12315 int ecode2 = 0 ;
12316 PyObject * obj0 = 0 ;
12317 PyObject * obj1 = 0 ;
12318 char * kwnames[] = {
12319 (char *) "self",(char *) "key", NULL
12320 };
12321
12322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12324 if (!SWIG_IsOK(res1)) {
12325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12326 }
12327 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12328 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12329 if (!SWIG_IsOK(ecode2)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12331 }
12332 arg2 = static_cast< unsigned long >(val2);
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj = 0;
12348 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12349 byte arg2 ;
12350 byte arg3 ;
12351 byte arg4 ;
12352 unsigned long result;
12353 void *argp1 = 0 ;
12354 int res1 = 0 ;
12355 unsigned char val2 ;
12356 int ecode2 = 0 ;
12357 unsigned char val3 ;
12358 int ecode3 = 0 ;
12359 unsigned char val4 ;
12360 int ecode4 = 0 ;
12361 PyObject * obj0 = 0 ;
12362 PyObject * obj1 = 0 ;
12363 PyObject * obj2 = 0 ;
12364 PyObject * obj3 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12367 };
12368
12369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12371 if (!SWIG_IsOK(res1)) {
12372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12373 }
12374 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12375 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12376 if (!SWIG_IsOK(ecode2)) {
12377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12378 }
12379 arg2 = static_cast< byte >(val2);
12380 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12381 if (!SWIG_IsOK(ecode3)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12383 }
12384 arg3 = static_cast< byte >(val3);
12385 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12386 if (!SWIG_IsOK(ecode4)) {
12387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12388 }
12389 arg4 = static_cast< byte >(val4);
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj = 0;
12405 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12406 wxColour *arg2 = 0 ;
12407 unsigned long result;
12408 void *argp1 = 0 ;
12409 int res1 = 0 ;
12410 wxColour temp2 ;
12411 PyObject * obj0 = 0 ;
12412 PyObject * obj1 = 0 ;
12413 char * kwnames[] = {
12414 (char *) "self",(char *) "colour", NULL
12415 };
12416
12417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12419 if (!SWIG_IsOK(res1)) {
12420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12421 }
12422 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12423 {
12424 arg2 = &temp2;
12425 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12426 }
12427 {
12428 PyThreadState* __tstate = wxPyBeginAllowThreads();
12429 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12441 PyObject *obj;
12442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12443 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12444 return SWIG_Py_Void();
12445 }
12446
12447 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12448 return SWIG_Python_InitShadowInstance(args);
12449 }
12450
12451 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj = 0;
12453 byte arg1 = (byte) 0 ;
12454 byte arg2 = (byte) 0 ;
12455 byte arg3 = (byte) 0 ;
12456 wxImage_RGBValue *result = 0 ;
12457 unsigned char val1 ;
12458 int ecode1 = 0 ;
12459 unsigned char val2 ;
12460 int ecode2 = 0 ;
12461 unsigned char val3 ;
12462 int ecode3 = 0 ;
12463 PyObject * obj0 = 0 ;
12464 PyObject * obj1 = 0 ;
12465 PyObject * obj2 = 0 ;
12466 char * kwnames[] = {
12467 (char *) "r",(char *) "g",(char *) "b", NULL
12468 };
12469
12470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12471 if (obj0) {
12472 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12473 if (!SWIG_IsOK(ecode1)) {
12474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12475 }
12476 arg1 = static_cast< byte >(val1);
12477 }
12478 if (obj1) {
12479 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12480 if (!SWIG_IsOK(ecode2)) {
12481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12482 }
12483 arg2 = static_cast< byte >(val2);
12484 }
12485 if (obj2) {
12486 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12487 if (!SWIG_IsOK(ecode3)) {
12488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12489 }
12490 arg3 = static_cast< byte >(val3);
12491 }
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12506 PyObject *resultobj = 0;
12507 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12508 byte arg2 ;
12509 void *argp1 = 0 ;
12510 int res1 = 0 ;
12511 unsigned char val2 ;
12512 int ecode2 = 0 ;
12513 PyObject *swig_obj[2] ;
12514
12515 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12517 if (!SWIG_IsOK(res1)) {
12518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12519 }
12520 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12521 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12522 if (!SWIG_IsOK(ecode2)) {
12523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12524 }
12525 arg2 = static_cast< byte >(val2);
12526 if (arg1) (arg1)->red = arg2;
12527
12528 resultobj = SWIG_Py_Void();
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12536 PyObject *resultobj = 0;
12537 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12538 byte result;
12539 void *argp1 = 0 ;
12540 int res1 = 0 ;
12541 PyObject *swig_obj[1] ;
12542
12543 if (!args) SWIG_fail;
12544 swig_obj[0] = args;
12545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12546 if (!SWIG_IsOK(res1)) {
12547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12548 }
12549 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12550 result = (byte) ((arg1)->red);
12551 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12552 return resultobj;
12553 fail:
12554 return NULL;
12555 }
12556
12557
12558 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12559 PyObject *resultobj = 0;
12560 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12561 byte arg2 ;
12562 void *argp1 = 0 ;
12563 int res1 = 0 ;
12564 unsigned char val2 ;
12565 int ecode2 = 0 ;
12566 PyObject *swig_obj[2] ;
12567
12568 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12570 if (!SWIG_IsOK(res1)) {
12571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12572 }
12573 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12574 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12575 if (!SWIG_IsOK(ecode2)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12577 }
12578 arg2 = static_cast< byte >(val2);
12579 if (arg1) (arg1)->green = arg2;
12580
12581 resultobj = SWIG_Py_Void();
12582 return resultobj;
12583 fail:
12584 return NULL;
12585 }
12586
12587
12588 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12589 PyObject *resultobj = 0;
12590 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12591 byte result;
12592 void *argp1 = 0 ;
12593 int res1 = 0 ;
12594 PyObject *swig_obj[1] ;
12595
12596 if (!args) SWIG_fail;
12597 swig_obj[0] = args;
12598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12599 if (!SWIG_IsOK(res1)) {
12600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12601 }
12602 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12603 result = (byte) ((arg1)->green);
12604 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612 PyObject *resultobj = 0;
12613 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12614 byte arg2 ;
12615 void *argp1 = 0 ;
12616 int res1 = 0 ;
12617 unsigned char val2 ;
12618 int ecode2 = 0 ;
12619 PyObject *swig_obj[2] ;
12620
12621 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12623 if (!SWIG_IsOK(res1)) {
12624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12625 }
12626 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12627 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12628 if (!SWIG_IsOK(ecode2)) {
12629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12630 }
12631 arg2 = static_cast< byte >(val2);
12632 if (arg1) (arg1)->blue = arg2;
12633
12634 resultobj = SWIG_Py_Void();
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12642 PyObject *resultobj = 0;
12643 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12644 byte result;
12645 void *argp1 = 0 ;
12646 int res1 = 0 ;
12647 PyObject *swig_obj[1] ;
12648
12649 if (!args) SWIG_fail;
12650 swig_obj[0] = args;
12651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12652 if (!SWIG_IsOK(res1)) {
12653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12654 }
12655 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12656 result = (byte) ((arg1)->blue);
12657 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665 PyObject *obj;
12666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12667 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12668 return SWIG_Py_Void();
12669 }
12670
12671 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12672 return SWIG_Python_InitShadowInstance(args);
12673 }
12674
12675 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj = 0;
12677 double arg1 = (double) 0.0 ;
12678 double arg2 = (double) 0.0 ;
12679 double arg3 = (double) 0.0 ;
12680 wxImage_HSVValue *result = 0 ;
12681 double val1 ;
12682 int ecode1 = 0 ;
12683 double val2 ;
12684 int ecode2 = 0 ;
12685 double val3 ;
12686 int ecode3 = 0 ;
12687 PyObject * obj0 = 0 ;
12688 PyObject * obj1 = 0 ;
12689 PyObject * obj2 = 0 ;
12690 char * kwnames[] = {
12691 (char *) "h",(char *) "s",(char *) "v", NULL
12692 };
12693
12694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12695 if (obj0) {
12696 ecode1 = SWIG_AsVal_double(obj0, &val1);
12697 if (!SWIG_IsOK(ecode1)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12699 }
12700 arg1 = static_cast< double >(val1);
12701 }
12702 if (obj1) {
12703 ecode2 = SWIG_AsVal_double(obj1, &val2);
12704 if (!SWIG_IsOK(ecode2)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12706 }
12707 arg2 = static_cast< double >(val2);
12708 }
12709 if (obj2) {
12710 ecode3 = SWIG_AsVal_double(obj2, &val3);
12711 if (!SWIG_IsOK(ecode3)) {
12712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12713 }
12714 arg3 = static_cast< double >(val3);
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12723 return resultobj;
12724 fail:
12725 return NULL;
12726 }
12727
12728
12729 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12730 PyObject *resultobj = 0;
12731 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12732 double arg2 ;
12733 void *argp1 = 0 ;
12734 int res1 = 0 ;
12735 double val2 ;
12736 int ecode2 = 0 ;
12737 PyObject *swig_obj[2] ;
12738
12739 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12743 }
12744 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12745 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12746 if (!SWIG_IsOK(ecode2)) {
12747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12748 }
12749 arg2 = static_cast< double >(val2);
12750 if (arg1) (arg1)->hue = arg2;
12751
12752 resultobj = SWIG_Py_Void();
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12760 PyObject *resultobj = 0;
12761 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12762 double result;
12763 void *argp1 = 0 ;
12764 int res1 = 0 ;
12765 PyObject *swig_obj[1] ;
12766
12767 if (!args) SWIG_fail;
12768 swig_obj[0] = args;
12769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12770 if (!SWIG_IsOK(res1)) {
12771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12772 }
12773 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12774 result = (double) ((arg1)->hue);
12775 resultobj = SWIG_From_double(static_cast< double >(result));
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12783 PyObject *resultobj = 0;
12784 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12785 double arg2 ;
12786 void *argp1 = 0 ;
12787 int res1 = 0 ;
12788 double val2 ;
12789 int ecode2 = 0 ;
12790 PyObject *swig_obj[2] ;
12791
12792 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12794 if (!SWIG_IsOK(res1)) {
12795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12796 }
12797 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12798 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12799 if (!SWIG_IsOK(ecode2)) {
12800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12801 }
12802 arg2 = static_cast< double >(val2);
12803 if (arg1) (arg1)->saturation = arg2;
12804
12805 resultobj = SWIG_Py_Void();
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12813 PyObject *resultobj = 0;
12814 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12815 double result;
12816 void *argp1 = 0 ;
12817 int res1 = 0 ;
12818 PyObject *swig_obj[1] ;
12819
12820 if (!args) SWIG_fail;
12821 swig_obj[0] = args;
12822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12823 if (!SWIG_IsOK(res1)) {
12824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12825 }
12826 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12827 result = (double) ((arg1)->saturation);
12828 resultobj = SWIG_From_double(static_cast< double >(result));
12829 return resultobj;
12830 fail:
12831 return NULL;
12832 }
12833
12834
12835 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12836 PyObject *resultobj = 0;
12837 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12838 double arg2 ;
12839 void *argp1 = 0 ;
12840 int res1 = 0 ;
12841 double val2 ;
12842 int ecode2 = 0 ;
12843 PyObject *swig_obj[2] ;
12844
12845 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12847 if (!SWIG_IsOK(res1)) {
12848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12849 }
12850 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12851 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12852 if (!SWIG_IsOK(ecode2)) {
12853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12854 }
12855 arg2 = static_cast< double >(val2);
12856 if (arg1) (arg1)->value = arg2;
12857
12858 resultobj = SWIG_Py_Void();
12859 return resultobj;
12860 fail:
12861 return NULL;
12862 }
12863
12864
12865 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12866 PyObject *resultobj = 0;
12867 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12868 double result;
12869 void *argp1 = 0 ;
12870 int res1 = 0 ;
12871 PyObject *swig_obj[1] ;
12872
12873 if (!args) SWIG_fail;
12874 swig_obj[0] = args;
12875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12876 if (!SWIG_IsOK(res1)) {
12877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12878 }
12879 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12880 result = (double) ((arg1)->value);
12881 resultobj = SWIG_From_double(static_cast< double >(result));
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 PyObject *obj;
12890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12891 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12892 return SWIG_Py_Void();
12893 }
12894
12895 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12896 return SWIG_Python_InitShadowInstance(args);
12897 }
12898
12899 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj = 0;
12901 wxString *arg1 = 0 ;
12902 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12903 int arg3 = (int) -1 ;
12904 wxImage *result = 0 ;
12905 bool temp1 = false ;
12906 long val2 ;
12907 int ecode2 = 0 ;
12908 int val3 ;
12909 int ecode3 = 0 ;
12910 PyObject * obj0 = 0 ;
12911 PyObject * obj1 = 0 ;
12912 PyObject * obj2 = 0 ;
12913 char * kwnames[] = {
12914 (char *) "name",(char *) "type",(char *) "index", NULL
12915 };
12916
12917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12918 {
12919 arg1 = wxString_in_helper(obj0);
12920 if (arg1 == NULL) SWIG_fail;
12921 temp1 = true;
12922 }
12923 if (obj1) {
12924 ecode2 = SWIG_AsVal_long(obj1, &val2);
12925 if (!SWIG_IsOK(ecode2)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12927 }
12928 arg2 = static_cast< long >(val2);
12929 }
12930 if (obj2) {
12931 ecode3 = SWIG_AsVal_int(obj2, &val3);
12932 if (!SWIG_IsOK(ecode3)) {
12933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12934 }
12935 arg3 = static_cast< int >(val3);
12936 }
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12944 {
12945 if (temp1)
12946 delete arg1;
12947 }
12948 return resultobj;
12949 fail:
12950 {
12951 if (temp1)
12952 delete arg1;
12953 }
12954 return NULL;
12955 }
12956
12957
12958 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 PyObject *resultobj = 0;
12960 wxImage *arg1 = (wxImage *) 0 ;
12961 void *argp1 = 0 ;
12962 int res1 = 0 ;
12963 PyObject *swig_obj[1] ;
12964
12965 if (!args) SWIG_fail;
12966 swig_obj[0] = args;
12967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12968 if (!SWIG_IsOK(res1)) {
12969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12970 }
12971 arg1 = reinterpret_cast< wxImage * >(argp1);
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 delete arg1;
12975
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 resultobj = SWIG_Py_Void();
12980 return resultobj;
12981 fail:
12982 return NULL;
12983 }
12984
12985
12986 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12987 PyObject *resultobj = 0;
12988 wxString *arg1 = 0 ;
12989 wxString *arg2 = 0 ;
12990 int arg3 = (int) -1 ;
12991 wxImage *result = 0 ;
12992 bool temp1 = false ;
12993 bool temp2 = false ;
12994 int val3 ;
12995 int ecode3 = 0 ;
12996 PyObject * obj0 = 0 ;
12997 PyObject * obj1 = 0 ;
12998 PyObject * obj2 = 0 ;
12999 char * kwnames[] = {
13000 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13001 };
13002
13003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13004 {
13005 arg1 = wxString_in_helper(obj0);
13006 if (arg1 == NULL) SWIG_fail;
13007 temp1 = true;
13008 }
13009 {
13010 arg2 = wxString_in_helper(obj1);
13011 if (arg2 == NULL) SWIG_fail;
13012 temp2 = true;
13013 }
13014 if (obj2) {
13015 ecode3 = SWIG_AsVal_int(obj2, &val3);
13016 if (!SWIG_IsOK(ecode3)) {
13017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13018 }
13019 arg3 = static_cast< int >(val3);
13020 }
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13028 {
13029 if (temp1)
13030 delete arg1;
13031 }
13032 {
13033 if (temp2)
13034 delete arg2;
13035 }
13036 return resultobj;
13037 fail:
13038 {
13039 if (temp1)
13040 delete arg1;
13041 }
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return NULL;
13047 }
13048
13049
13050 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13051 PyObject *resultobj = 0;
13052 wxInputStream *arg1 = 0 ;
13053 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13054 int arg3 = (int) -1 ;
13055 wxImage *result = 0 ;
13056 wxPyInputStream *temp1 ;
13057 bool created1 ;
13058 long val2 ;
13059 int ecode2 = 0 ;
13060 int val3 ;
13061 int ecode3 = 0 ;
13062 PyObject * obj0 = 0 ;
13063 PyObject * obj1 = 0 ;
13064 PyObject * obj2 = 0 ;
13065 char * kwnames[] = {
13066 (char *) "stream",(char *) "type",(char *) "index", NULL
13067 };
13068
13069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13070 {
13071 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13072 arg1 = temp1->m_wxis;
13073 created1 = false;
13074 } else {
13075 PyErr_Clear(); // clear the failure of the wxPyConvert above
13076 arg1 = wxPyCBInputStream_create(obj0, false);
13077 if (arg1 == NULL) {
13078 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13079 SWIG_fail;
13080 }
13081 created1 = true;
13082 }
13083 }
13084 if (obj1) {
13085 ecode2 = SWIG_AsVal_long(obj1, &val2);
13086 if (!SWIG_IsOK(ecode2)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13088 }
13089 arg2 = static_cast< long >(val2);
13090 }
13091 if (obj2) {
13092 ecode3 = SWIG_AsVal_int(obj2, &val3);
13093 if (!SWIG_IsOK(ecode3)) {
13094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13095 }
13096 arg3 = static_cast< int >(val3);
13097 }
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13105 {
13106 if (created1) delete arg1;
13107 }
13108 return resultobj;
13109 fail:
13110 {
13111 if (created1) delete arg1;
13112 }
13113 return NULL;
13114 }
13115
13116
13117 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = 0;
13119 wxInputStream *arg1 = 0 ;
13120 wxString *arg2 = 0 ;
13121 int arg3 = (int) -1 ;
13122 wxImage *result = 0 ;
13123 wxPyInputStream *temp1 ;
13124 bool created1 ;
13125 bool temp2 = false ;
13126 int val3 ;
13127 int ecode3 = 0 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 PyObject * obj2 = 0 ;
13131 char * kwnames[] = {
13132 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13133 };
13134
13135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13136 {
13137 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13138 arg1 = temp1->m_wxis;
13139 created1 = false;
13140 } else {
13141 PyErr_Clear(); // clear the failure of the wxPyConvert above
13142 arg1 = wxPyCBInputStream_create(obj0, false);
13143 if (arg1 == NULL) {
13144 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13145 SWIG_fail;
13146 }
13147 created1 = true;
13148 }
13149 }
13150 {
13151 arg2 = wxString_in_helper(obj1);
13152 if (arg2 == NULL) SWIG_fail;
13153 temp2 = true;
13154 }
13155 if (obj2) {
13156 ecode3 = SWIG_AsVal_int(obj2, &val3);
13157 if (!SWIG_IsOK(ecode3)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13159 }
13160 arg3 = static_cast< int >(val3);
13161 }
13162 {
13163 PyThreadState* __tstate = wxPyBeginAllowThreads();
13164 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13169 {
13170 if (created1) delete arg1;
13171 }
13172 {
13173 if (temp2)
13174 delete arg2;
13175 }
13176 return resultobj;
13177 fail:
13178 {
13179 if (created1) delete arg1;
13180 }
13181 {
13182 if (temp2)
13183 delete arg2;
13184 }
13185 return NULL;
13186 }
13187
13188
13189 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj = 0;
13191 int arg1 = (int) 0 ;
13192 int arg2 = (int) 0 ;
13193 bool arg3 = (bool) true ;
13194 wxImage *result = 0 ;
13195 int val1 ;
13196 int ecode1 = 0 ;
13197 int val2 ;
13198 int ecode2 = 0 ;
13199 bool val3 ;
13200 int ecode3 = 0 ;
13201 PyObject * obj0 = 0 ;
13202 PyObject * obj1 = 0 ;
13203 PyObject * obj2 = 0 ;
13204 char * kwnames[] = {
13205 (char *) "width",(char *) "height",(char *) "clear", NULL
13206 };
13207
13208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13209 if (obj0) {
13210 ecode1 = SWIG_AsVal_int(obj0, &val1);
13211 if (!SWIG_IsOK(ecode1)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13213 }
13214 arg1 = static_cast< int >(val1);
13215 }
13216 if (obj1) {
13217 ecode2 = SWIG_AsVal_int(obj1, &val2);
13218 if (!SWIG_IsOK(ecode2)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13220 }
13221 arg2 = static_cast< int >(val2);
13222 }
13223 if (obj2) {
13224 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13225 if (!SWIG_IsOK(ecode3)) {
13226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13227 }
13228 arg3 = static_cast< bool >(val3);
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13237 return resultobj;
13238 fail:
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj = 0;
13245 wxBitmap *arg1 = 0 ;
13246 wxImage *result = 0 ;
13247 void *argp1 = 0 ;
13248 int res1 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "bitmap", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13258 }
13259 if (!argp1) {
13260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13261 }
13262 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13263 {
13264 if (!wxPyCheckForApp()) SWIG_fail;
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13267 wxPyEndAllowThreads(__tstate);
13268 if (PyErr_Occurred()) SWIG_fail;
13269 }
13270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 int arg1 ;
13280 int arg2 ;
13281 buffer arg3 ;
13282 int arg4 ;
13283 wxImage *result = 0 ;
13284 int val1 ;
13285 int ecode1 = 0 ;
13286 int val2 ;
13287 int ecode2 = 0 ;
13288 PyObject * obj0 = 0 ;
13289 PyObject * obj1 = 0 ;
13290 PyObject * obj2 = 0 ;
13291 char * kwnames[] = {
13292 (char *) "width",(char *) "height",(char *) "data", NULL
13293 };
13294
13295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13296 ecode1 = SWIG_AsVal_int(obj0, &val1);
13297 if (!SWIG_IsOK(ecode1)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13299 }
13300 arg1 = static_cast< int >(val1);
13301 ecode2 = SWIG_AsVal_int(obj1, &val2);
13302 if (!SWIG_IsOK(ecode2)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13304 }
13305 arg2 = static_cast< int >(val2);
13306 {
13307 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13308 }
13309 {
13310 PyThreadState* __tstate = wxPyBeginAllowThreads();
13311 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13312 wxPyEndAllowThreads(__tstate);
13313 if (PyErr_Occurred()) SWIG_fail;
13314 }
13315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13323 PyObject *resultobj = 0;
13324 int arg1 ;
13325 int arg2 ;
13326 buffer arg3 ;
13327 int arg4 ;
13328 buffer arg5 ;
13329 int arg6 ;
13330 wxImage *result = 0 ;
13331 int val1 ;
13332 int ecode1 = 0 ;
13333 int val2 ;
13334 int ecode2 = 0 ;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 PyObject * obj2 = 0 ;
13338 PyObject * obj3 = 0 ;
13339 char * kwnames[] = {
13340 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13341 };
13342
13343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13344 ecode1 = SWIG_AsVal_int(obj0, &val1);
13345 if (!SWIG_IsOK(ecode1)) {
13346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13347 }
13348 arg1 = static_cast< int >(val1);
13349 ecode2 = SWIG_AsVal_int(obj1, &val2);
13350 if (!SWIG_IsOK(ecode2)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13352 }
13353 arg2 = static_cast< int >(val2);
13354 {
13355 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13356 }
13357 {
13358 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13359 }
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj = 0;
13375 wxImage *arg1 = (wxImage *) 0 ;
13376 int arg2 ;
13377 int arg3 ;
13378 bool arg4 = (bool) true ;
13379 void *argp1 = 0 ;
13380 int res1 = 0 ;
13381 int val2 ;
13382 int ecode2 = 0 ;
13383 int val3 ;
13384 int ecode3 = 0 ;
13385 bool val4 ;
13386 int ecode4 = 0 ;
13387 PyObject * obj0 = 0 ;
13388 PyObject * obj1 = 0 ;
13389 PyObject * obj2 = 0 ;
13390 PyObject * obj3 = 0 ;
13391 char * kwnames[] = {
13392 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13393 };
13394
13395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13397 if (!SWIG_IsOK(res1)) {
13398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13399 }
13400 arg1 = reinterpret_cast< wxImage * >(argp1);
13401 ecode2 = SWIG_AsVal_int(obj1, &val2);
13402 if (!SWIG_IsOK(ecode2)) {
13403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13404 }
13405 arg2 = static_cast< int >(val2);
13406 ecode3 = SWIG_AsVal_int(obj2, &val3);
13407 if (!SWIG_IsOK(ecode3)) {
13408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13409 }
13410 arg3 = static_cast< int >(val3);
13411 if (obj3) {
13412 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13413 if (!SWIG_IsOK(ecode4)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13415 }
13416 arg4 = static_cast< bool >(val4);
13417 }
13418 {
13419 PyThreadState* __tstate = wxPyBeginAllowThreads();
13420 (arg1)->Create(arg2,arg3,arg4);
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 resultobj = SWIG_Py_Void();
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 wxImage *arg1 = (wxImage *) 0 ;
13434 void *argp1 = 0 ;
13435 int res1 = 0 ;
13436 PyObject *swig_obj[1] ;
13437
13438 if (!args) SWIG_fail;
13439 swig_obj[0] = args;
13440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13441 if (!SWIG_IsOK(res1)) {
13442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13443 }
13444 arg1 = reinterpret_cast< wxImage * >(argp1);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 (arg1)->Destroy();
13448 wxPyEndAllowThreads(__tstate);
13449 if (PyErr_Occurred()) SWIG_fail;
13450 }
13451 resultobj = SWIG_Py_Void();
13452 return resultobj;
13453 fail:
13454 return NULL;
13455 }
13456
13457
13458 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13459 PyObject *resultobj = 0;
13460 wxImage *arg1 = (wxImage *) 0 ;
13461 int arg2 ;
13462 int arg3 ;
13463 SwigValueWrapper<wxImage > result;
13464 void *argp1 = 0 ;
13465 int res1 = 0 ;
13466 int val2 ;
13467 int ecode2 = 0 ;
13468 int val3 ;
13469 int ecode3 = 0 ;
13470 PyObject * obj0 = 0 ;
13471 PyObject * obj1 = 0 ;
13472 PyObject * obj2 = 0 ;
13473 char * kwnames[] = {
13474 (char *) "self",(char *) "width",(char *) "height", NULL
13475 };
13476
13477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13481 }
13482 arg1 = reinterpret_cast< wxImage * >(argp1);
13483 ecode2 = SWIG_AsVal_int(obj1, &val2);
13484 if (!SWIG_IsOK(ecode2)) {
13485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13486 }
13487 arg2 = static_cast< int >(val2);
13488 ecode3 = SWIG_AsVal_int(obj2, &val3);
13489 if (!SWIG_IsOK(ecode3)) {
13490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13491 }
13492 arg3 = static_cast< int >(val3);
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = (arg1)->Scale(arg2,arg3);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 int arg2 ;
13510 int arg3 ;
13511 SwigValueWrapper<wxImage > result;
13512 void *argp1 = 0 ;
13513 int res1 = 0 ;
13514 int val2 ;
13515 int ecode2 = 0 ;
13516 int val3 ;
13517 int ecode3 = 0 ;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 PyObject * obj2 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13527 if (!SWIG_IsOK(res1)) {
13528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13529 }
13530 arg1 = reinterpret_cast< wxImage * >(argp1);
13531 ecode2 = SWIG_AsVal_int(obj1, &val2);
13532 if (!SWIG_IsOK(ecode2)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13534 }
13535 arg2 = static_cast< int >(val2);
13536 ecode3 = SWIG_AsVal_int(obj2, &val3);
13537 if (!SWIG_IsOK(ecode3)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13539 }
13540 arg3 = static_cast< int >(val3);
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13548 return resultobj;
13549 fail:
13550 return NULL;
13551 }
13552
13553
13554 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj = 0;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 int arg2 ;
13558 int arg3 ;
13559 wxImage *result = 0 ;
13560 void *argp1 = 0 ;
13561 int res1 = 0 ;
13562 int val2 ;
13563 int ecode2 = 0 ;
13564 int val3 ;
13565 int ecode3 = 0 ;
13566 PyObject * obj0 = 0 ;
13567 PyObject * obj1 = 0 ;
13568 PyObject * obj2 = 0 ;
13569 char * kwnames[] = {
13570 (char *) "self",(char *) "width",(char *) "height", NULL
13571 };
13572
13573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13575 if (!SWIG_IsOK(res1)) {
13576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13577 }
13578 arg1 = reinterpret_cast< wxImage * >(argp1);
13579 ecode2 = SWIG_AsVal_int(obj1, &val2);
13580 if (!SWIG_IsOK(ecode2)) {
13581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13582 }
13583 arg2 = static_cast< int >(val2);
13584 ecode3 = SWIG_AsVal_int(obj2, &val3);
13585 if (!SWIG_IsOK(ecode3)) {
13586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13587 }
13588 arg3 = static_cast< int >(val3);
13589 {
13590 PyThreadState* __tstate = wxPyBeginAllowThreads();
13591 {
13592 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13593 result = (wxImage *) &_result_ref;
13594 }
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj = 0;
13607 wxImage *arg1 = (wxImage *) 0 ;
13608 wxSize *arg2 = 0 ;
13609 wxPoint *arg3 = 0 ;
13610 int arg4 = (int) -1 ;
13611 int arg5 = (int) -1 ;
13612 int arg6 = (int) -1 ;
13613 wxImage *result = 0 ;
13614 void *argp1 = 0 ;
13615 int res1 = 0 ;
13616 wxSize temp2 ;
13617 wxPoint temp3 ;
13618 int val4 ;
13619 int ecode4 = 0 ;
13620 int val5 ;
13621 int ecode5 = 0 ;
13622 int val6 ;
13623 int ecode6 = 0 ;
13624 PyObject * obj0 = 0 ;
13625 PyObject * obj1 = 0 ;
13626 PyObject * obj2 = 0 ;
13627 PyObject * obj3 = 0 ;
13628 PyObject * obj4 = 0 ;
13629 PyObject * obj5 = 0 ;
13630 char * kwnames[] = {
13631 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13632 };
13633
13634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13636 if (!SWIG_IsOK(res1)) {
13637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13638 }
13639 arg1 = reinterpret_cast< wxImage * >(argp1);
13640 {
13641 arg2 = &temp2;
13642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13643 }
13644 {
13645 arg3 = &temp3;
13646 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13647 }
13648 if (obj3) {
13649 ecode4 = SWIG_AsVal_int(obj3, &val4);
13650 if (!SWIG_IsOK(ecode4)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13652 }
13653 arg4 = static_cast< int >(val4);
13654 }
13655 if (obj4) {
13656 ecode5 = SWIG_AsVal_int(obj4, &val5);
13657 if (!SWIG_IsOK(ecode5)) {
13658 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13659 }
13660 arg5 = static_cast< int >(val5);
13661 }
13662 if (obj5) {
13663 ecode6 = SWIG_AsVal_int(obj5, &val6);
13664 if (!SWIG_IsOK(ecode6)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13666 }
13667 arg6 = static_cast< int >(val6);
13668 }
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 {
13672 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13673 result = (wxImage *) &_result_ref;
13674 }
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxImage *arg1 = (wxImage *) 0 ;
13688 int arg2 ;
13689 int arg3 ;
13690 byte arg4 ;
13691 byte arg5 ;
13692 byte arg6 ;
13693 void *argp1 = 0 ;
13694 int res1 = 0 ;
13695 int val2 ;
13696 int ecode2 = 0 ;
13697 int val3 ;
13698 int ecode3 = 0 ;
13699 unsigned char val4 ;
13700 int ecode4 = 0 ;
13701 unsigned char val5 ;
13702 int ecode5 = 0 ;
13703 unsigned char val6 ;
13704 int ecode6 = 0 ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 PyObject * obj2 = 0 ;
13708 PyObject * obj3 = 0 ;
13709 PyObject * obj4 = 0 ;
13710 PyObject * obj5 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13719 }
13720 arg1 = reinterpret_cast< wxImage * >(argp1);
13721 ecode2 = SWIG_AsVal_int(obj1, &val2);
13722 if (!SWIG_IsOK(ecode2)) {
13723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13724 }
13725 arg2 = static_cast< int >(val2);
13726 ecode3 = SWIG_AsVal_int(obj2, &val3);
13727 if (!SWIG_IsOK(ecode3)) {
13728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13729 }
13730 arg3 = static_cast< int >(val3);
13731 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13732 if (!SWIG_IsOK(ecode4)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13734 }
13735 arg4 = static_cast< byte >(val4);
13736 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13737 if (!SWIG_IsOK(ecode5)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13739 }
13740 arg5 = static_cast< byte >(val5);
13741 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13742 if (!SWIG_IsOK(ecode6)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13744 }
13745 arg6 = static_cast< byte >(val6);
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 resultobj = SWIG_Py_Void();
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 wxImage *arg1 = (wxImage *) 0 ;
13762 wxRect *arg2 = 0 ;
13763 byte arg3 ;
13764 byte arg4 ;
13765 byte arg5 ;
13766 void *argp1 = 0 ;
13767 int res1 = 0 ;
13768 wxRect temp2 ;
13769 unsigned char val3 ;
13770 int ecode3 = 0 ;
13771 unsigned char val4 ;
13772 int ecode4 = 0 ;
13773 unsigned char val5 ;
13774 int ecode5 = 0 ;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 PyObject * obj3 = 0 ;
13779 PyObject * obj4 = 0 ;
13780 char * kwnames[] = {
13781 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13782 };
13783
13784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13786 if (!SWIG_IsOK(res1)) {
13787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13788 }
13789 arg1 = reinterpret_cast< wxImage * >(argp1);
13790 {
13791 arg2 = &temp2;
13792 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13793 }
13794 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13795 if (!SWIG_IsOK(ecode3)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13797 }
13798 arg3 = static_cast< byte >(val3);
13799 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13800 if (!SWIG_IsOK(ecode4)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13802 }
13803 arg4 = static_cast< byte >(val4);
13804 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13805 if (!SWIG_IsOK(ecode5)) {
13806 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13807 }
13808 arg5 = static_cast< byte >(val5);
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_Py_Void();
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj = 0;
13824 wxImage *arg1 = (wxImage *) 0 ;
13825 int arg2 ;
13826 int arg3 ;
13827 byte result;
13828 void *argp1 = 0 ;
13829 int res1 = 0 ;
13830 int val2 ;
13831 int ecode2 = 0 ;
13832 int val3 ;
13833 int ecode3 = 0 ;
13834 PyObject * obj0 = 0 ;
13835 PyObject * obj1 = 0 ;
13836 PyObject * obj2 = 0 ;
13837 char * kwnames[] = {
13838 (char *) "self",(char *) "x",(char *) "y", NULL
13839 };
13840
13841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13843 if (!SWIG_IsOK(res1)) {
13844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13845 }
13846 arg1 = reinterpret_cast< wxImage * >(argp1);
13847 ecode2 = SWIG_AsVal_int(obj1, &val2);
13848 if (!SWIG_IsOK(ecode2)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13850 }
13851 arg2 = static_cast< int >(val2);
13852 ecode3 = SWIG_AsVal_int(obj2, &val3);
13853 if (!SWIG_IsOK(ecode3)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13855 }
13856 arg3 = static_cast< int >(val3);
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (byte)(arg1)->GetRed(arg2,arg3);
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13864 return resultobj;
13865 fail:
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 wxImage *arg1 = (wxImage *) 0 ;
13873 int arg2 ;
13874 int arg3 ;
13875 byte result;
13876 void *argp1 = 0 ;
13877 int res1 = 0 ;
13878 int val2 ;
13879 int ecode2 = 0 ;
13880 int val3 ;
13881 int ecode3 = 0 ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 PyObject * obj2 = 0 ;
13885 char * kwnames[] = {
13886 (char *) "self",(char *) "x",(char *) "y", NULL
13887 };
13888
13889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13891 if (!SWIG_IsOK(res1)) {
13892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13893 }
13894 arg1 = reinterpret_cast< wxImage * >(argp1);
13895 ecode2 = SWIG_AsVal_int(obj1, &val2);
13896 if (!SWIG_IsOK(ecode2)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13898 }
13899 arg2 = static_cast< int >(val2);
13900 ecode3 = SWIG_AsVal_int(obj2, &val3);
13901 if (!SWIG_IsOK(ecode3)) {
13902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13903 }
13904 arg3 = static_cast< int >(val3);
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 result = (byte)(arg1)->GetGreen(arg2,arg3);
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj = 0;
13920 wxImage *arg1 = (wxImage *) 0 ;
13921 int arg2 ;
13922 int arg3 ;
13923 byte result;
13924 void *argp1 = 0 ;
13925 int res1 = 0 ;
13926 int val2 ;
13927 int ecode2 = 0 ;
13928 int val3 ;
13929 int ecode3 = 0 ;
13930 PyObject * obj0 = 0 ;
13931 PyObject * obj1 = 0 ;
13932 PyObject * obj2 = 0 ;
13933 char * kwnames[] = {
13934 (char *) "self",(char *) "x",(char *) "y", NULL
13935 };
13936
13937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13939 if (!SWIG_IsOK(res1)) {
13940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13941 }
13942 arg1 = reinterpret_cast< wxImage * >(argp1);
13943 ecode2 = SWIG_AsVal_int(obj1, &val2);
13944 if (!SWIG_IsOK(ecode2)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13946 }
13947 arg2 = static_cast< int >(val2);
13948 ecode3 = SWIG_AsVal_int(obj2, &val3);
13949 if (!SWIG_IsOK(ecode3)) {
13950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13951 }
13952 arg3 = static_cast< int >(val3);
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 result = (byte)(arg1)->GetBlue(arg2,arg3);
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13960 return resultobj;
13961 fail:
13962 return NULL;
13963 }
13964
13965
13966 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13967 PyObject *resultobj = 0;
13968 wxImage *arg1 = (wxImage *) 0 ;
13969 int arg2 ;
13970 int arg3 ;
13971 byte arg4 ;
13972 void *argp1 = 0 ;
13973 int res1 = 0 ;
13974 int val2 ;
13975 int ecode2 = 0 ;
13976 int val3 ;
13977 int ecode3 = 0 ;
13978 unsigned char val4 ;
13979 int ecode4 = 0 ;
13980 PyObject * obj0 = 0 ;
13981 PyObject * obj1 = 0 ;
13982 PyObject * obj2 = 0 ;
13983 PyObject * obj3 = 0 ;
13984 char * kwnames[] = {
13985 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13986 };
13987
13988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13990 if (!SWIG_IsOK(res1)) {
13991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13992 }
13993 arg1 = reinterpret_cast< wxImage * >(argp1);
13994 ecode2 = SWIG_AsVal_int(obj1, &val2);
13995 if (!SWIG_IsOK(ecode2)) {
13996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13997 }
13998 arg2 = static_cast< int >(val2);
13999 ecode3 = SWIG_AsVal_int(obj2, &val3);
14000 if (!SWIG_IsOK(ecode3)) {
14001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14002 }
14003 arg3 = static_cast< int >(val3);
14004 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14005 if (!SWIG_IsOK(ecode4)) {
14006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14007 }
14008 arg4 = static_cast< byte >(val4);
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 (arg1)->SetAlpha(arg2,arg3,arg4);
14012 wxPyEndAllowThreads(__tstate);
14013 if (PyErr_Occurred()) SWIG_fail;
14014 }
14015 resultobj = SWIG_Py_Void();
14016 return resultobj;
14017 fail:
14018 return NULL;
14019 }
14020
14021
14022 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14023 PyObject *resultobj = 0;
14024 wxImage *arg1 = (wxImage *) 0 ;
14025 int arg2 ;
14026 int arg3 ;
14027 byte result;
14028 void *argp1 = 0 ;
14029 int res1 = 0 ;
14030 int val2 ;
14031 int ecode2 = 0 ;
14032 int val3 ;
14033 int ecode3 = 0 ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 PyObject * obj2 = 0 ;
14037 char * kwnames[] = {
14038 (char *) "self",(char *) "x",(char *) "y", NULL
14039 };
14040
14041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14043 if (!SWIG_IsOK(res1)) {
14044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14045 }
14046 arg1 = reinterpret_cast< wxImage * >(argp1);
14047 ecode2 = SWIG_AsVal_int(obj1, &val2);
14048 if (!SWIG_IsOK(ecode2)) {
14049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14050 }
14051 arg2 = static_cast< int >(val2);
14052 ecode3 = SWIG_AsVal_int(obj2, &val3);
14053 if (!SWIG_IsOK(ecode3)) {
14054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14055 }
14056 arg3 = static_cast< int >(val3);
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14071 PyObject *resultobj = 0;
14072 wxImage *arg1 = (wxImage *) 0 ;
14073 bool result;
14074 void *argp1 = 0 ;
14075 int res1 = 0 ;
14076 PyObject *swig_obj[1] ;
14077
14078 if (!args) SWIG_fail;
14079 swig_obj[0] = args;
14080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14083 }
14084 arg1 = reinterpret_cast< wxImage * >(argp1);
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 result = (bool)(arg1)->HasAlpha();
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 {
14092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14093 }
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14101 PyObject *resultobj = 0;
14102 wxImage *arg1 = (wxImage *) 0 ;
14103 void *argp1 = 0 ;
14104 int res1 = 0 ;
14105 PyObject *swig_obj[1] ;
14106
14107 if (!args) SWIG_fail;
14108 swig_obj[0] = args;
14109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14112 }
14113 arg1 = reinterpret_cast< wxImage * >(argp1);
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 (arg1)->InitAlpha();
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 resultobj = SWIG_Py_Void();
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj = 0;
14129 wxImage *arg1 = (wxImage *) 0 ;
14130 int arg2 ;
14131 int arg3 ;
14132 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14133 bool result;
14134 void *argp1 = 0 ;
14135 int res1 = 0 ;
14136 int val2 ;
14137 int ecode2 = 0 ;
14138 int val3 ;
14139 int ecode3 = 0 ;
14140 unsigned char val4 ;
14141 int ecode4 = 0 ;
14142 PyObject * obj0 = 0 ;
14143 PyObject * obj1 = 0 ;
14144 PyObject * obj2 = 0 ;
14145 PyObject * obj3 = 0 ;
14146 char * kwnames[] = {
14147 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14148 };
14149
14150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14152 if (!SWIG_IsOK(res1)) {
14153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14154 }
14155 arg1 = reinterpret_cast< wxImage * >(argp1);
14156 ecode2 = SWIG_AsVal_int(obj1, &val2);
14157 if (!SWIG_IsOK(ecode2)) {
14158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14159 }
14160 arg2 = static_cast< int >(val2);
14161 ecode3 = SWIG_AsVal_int(obj2, &val3);
14162 if (!SWIG_IsOK(ecode3)) {
14163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14164 }
14165 arg3 = static_cast< int >(val3);
14166 if (obj3) {
14167 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14168 if (!SWIG_IsOK(ecode4)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14170 }
14171 arg4 = static_cast< byte >(val4);
14172 }
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 {
14180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = 0;
14190 wxImage *arg1 = (wxImage *) 0 ;
14191 byte *arg2 = (byte *) 0 ;
14192 byte *arg3 = (byte *) 0 ;
14193 byte *arg4 = (byte *) 0 ;
14194 byte arg5 = (byte) 0 ;
14195 byte arg6 = (byte) 0 ;
14196 byte arg7 = (byte) 0 ;
14197 bool result;
14198 void *argp1 = 0 ;
14199 int res1 = 0 ;
14200 byte temp2 ;
14201 int res2 = SWIG_TMPOBJ ;
14202 byte temp3 ;
14203 int res3 = SWIG_TMPOBJ ;
14204 byte temp4 ;
14205 int res4 = SWIG_TMPOBJ ;
14206 unsigned char val5 ;
14207 int ecode5 = 0 ;
14208 unsigned char val6 ;
14209 int ecode6 = 0 ;
14210 unsigned char val7 ;
14211 int ecode7 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 PyObject * obj2 = 0 ;
14215 PyObject * obj3 = 0 ;
14216 char * kwnames[] = {
14217 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14218 };
14219
14220 arg2 = &temp2;
14221 arg3 = &temp3;
14222 arg4 = &temp4;
14223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14225 if (!SWIG_IsOK(res1)) {
14226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14227 }
14228 arg1 = reinterpret_cast< wxImage * >(argp1);
14229 if (obj1) {
14230 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14231 if (!SWIG_IsOK(ecode5)) {
14232 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14233 }
14234 arg5 = static_cast< byte >(val5);
14235 }
14236 if (obj2) {
14237 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14238 if (!SWIG_IsOK(ecode6)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14240 }
14241 arg6 = static_cast< byte >(val6);
14242 }
14243 if (obj3) {
14244 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14245 if (!SWIG_IsOK(ecode7)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14247 }
14248 arg7 = static_cast< byte >(val7);
14249 }
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 {
14257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14258 }
14259 if (SWIG_IsTmpObj(res2)) {
14260 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14261 } else {
14262 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14264 }
14265 if (SWIG_IsTmpObj(res3)) {
14266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14267 } else {
14268 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14270 }
14271 if (SWIG_IsTmpObj(res4)) {
14272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14273 } else {
14274 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14276 }
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj = 0;
14285 wxImage *arg1 = (wxImage *) 0 ;
14286 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14287 bool result;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 unsigned char val2 ;
14291 int ecode2 = 0 ;
14292 PyObject * obj0 = 0 ;
14293 PyObject * obj1 = 0 ;
14294 char * kwnames[] = {
14295 (char *) "self",(char *) "threshold", NULL
14296 };
14297
14298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14302 }
14303 arg1 = reinterpret_cast< wxImage * >(argp1);
14304 if (obj1) {
14305 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14306 if (!SWIG_IsOK(ecode2)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14308 }
14309 arg2 = static_cast< byte >(val2);
14310 }
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 {
14318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14319 }
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14327 PyObject *resultobj = 0;
14328 wxImage *arg1 = (wxImage *) 0 ;
14329 byte arg2 ;
14330 byte arg3 ;
14331 byte arg4 ;
14332 bool result;
14333 void *argp1 = 0 ;
14334 int res1 = 0 ;
14335 unsigned char val2 ;
14336 int ecode2 = 0 ;
14337 unsigned char val3 ;
14338 int ecode3 = 0 ;
14339 unsigned char val4 ;
14340 int ecode4 = 0 ;
14341 PyObject * obj0 = 0 ;
14342 PyObject * obj1 = 0 ;
14343 PyObject * obj2 = 0 ;
14344 PyObject * obj3 = 0 ;
14345 char * kwnames[] = {
14346 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14347 };
14348
14349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14351 if (!SWIG_IsOK(res1)) {
14352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14353 }
14354 arg1 = reinterpret_cast< wxImage * >(argp1);
14355 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14356 if (!SWIG_IsOK(ecode2)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14358 }
14359 arg2 = static_cast< byte >(val2);
14360 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14361 if (!SWIG_IsOK(ecode3)) {
14362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14363 }
14364 arg3 = static_cast< byte >(val3);
14365 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14366 if (!SWIG_IsOK(ecode4)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14368 }
14369 arg4 = static_cast< byte >(val4);
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 {
14377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14378 }
14379 return resultobj;
14380 fail:
14381 return NULL;
14382 }
14383
14384
14385 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14386 PyObject *resultobj = 0;
14387 wxImage *arg1 = (wxImage *) 0 ;
14388 wxImage *arg2 = 0 ;
14389 byte arg3 ;
14390 byte arg4 ;
14391 byte arg5 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 void *argp2 = 0 ;
14396 int res2 = 0 ;
14397 unsigned char val3 ;
14398 int ecode3 = 0 ;
14399 unsigned char val4 ;
14400 int ecode4 = 0 ;
14401 unsigned char val5 ;
14402 int ecode5 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 PyObject * obj3 = 0 ;
14407 PyObject * obj4 = 0 ;
14408 char * kwnames[] = {
14409 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14410 };
14411
14412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14414 if (!SWIG_IsOK(res1)) {
14415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14416 }
14417 arg1 = reinterpret_cast< wxImage * >(argp1);
14418 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14419 if (!SWIG_IsOK(res2)) {
14420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14421 }
14422 if (!argp2) {
14423 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14424 }
14425 arg2 = reinterpret_cast< wxImage * >(argp2);
14426 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14427 if (!SWIG_IsOK(ecode3)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14429 }
14430 arg3 = static_cast< byte >(val3);
14431 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14432 if (!SWIG_IsOK(ecode4)) {
14433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14434 }
14435 arg4 = static_cast< byte >(val4);
14436 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14437 if (!SWIG_IsOK(ecode5)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14439 }
14440 arg5 = static_cast< byte >(val5);
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 {
14448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14449 }
14450 return resultobj;
14451 fail:
14452 return NULL;
14453 }
14454
14455
14456 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14457 PyObject *resultobj = 0;
14458 wxString *arg1 = 0 ;
14459 bool result;
14460 bool temp1 = false ;
14461 PyObject * obj0 = 0 ;
14462 char * kwnames[] = {
14463 (char *) "filename", NULL
14464 };
14465
14466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14467 {
14468 arg1 = wxString_in_helper(obj0);
14469 if (arg1 == NULL) SWIG_fail;
14470 temp1 = true;
14471 }
14472 {
14473 PyThreadState* __tstate = wxPyBeginAllowThreads();
14474 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14475 wxPyEndAllowThreads(__tstate);
14476 if (PyErr_Occurred()) SWIG_fail;
14477 }
14478 {
14479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14480 }
14481 {
14482 if (temp1)
14483 delete arg1;
14484 }
14485 return resultobj;
14486 fail:
14487 {
14488 if (temp1)
14489 delete arg1;
14490 }
14491 return NULL;
14492 }
14493
14494
14495 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14496 PyObject *resultobj = 0;
14497 wxString *arg1 = 0 ;
14498 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14499 int result;
14500 bool temp1 = false ;
14501 long val2 ;
14502 int ecode2 = 0 ;
14503 PyObject * obj0 = 0 ;
14504 PyObject * obj1 = 0 ;
14505 char * kwnames[] = {
14506 (char *) "filename",(char *) "type", NULL
14507 };
14508
14509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14510 {
14511 arg1 = wxString_in_helper(obj0);
14512 if (arg1 == NULL) SWIG_fail;
14513 temp1 = true;
14514 }
14515 if (obj1) {
14516 ecode2 = SWIG_AsVal_long(obj1, &val2);
14517 if (!SWIG_IsOK(ecode2)) {
14518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14519 }
14520 arg2 = static_cast< long >(val2);
14521 }
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = SWIG_From_int(static_cast< int >(result));
14529 {
14530 if (temp1)
14531 delete arg1;
14532 }
14533 return resultobj;
14534 fail:
14535 {
14536 if (temp1)
14537 delete arg1;
14538 }
14539 return NULL;
14540 }
14541
14542
14543 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj = 0;
14545 wxImage *arg1 = (wxImage *) 0 ;
14546 wxString *arg2 = 0 ;
14547 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14548 int arg4 = (int) -1 ;
14549 bool result;
14550 void *argp1 = 0 ;
14551 int res1 = 0 ;
14552 bool temp2 = false ;
14553 long val3 ;
14554 int ecode3 = 0 ;
14555 int val4 ;
14556 int ecode4 = 0 ;
14557 PyObject * obj0 = 0 ;
14558 PyObject * obj1 = 0 ;
14559 PyObject * obj2 = 0 ;
14560 PyObject * obj3 = 0 ;
14561 char * kwnames[] = {
14562 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14563 };
14564
14565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14567 if (!SWIG_IsOK(res1)) {
14568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14569 }
14570 arg1 = reinterpret_cast< wxImage * >(argp1);
14571 {
14572 arg2 = wxString_in_helper(obj1);
14573 if (arg2 == NULL) SWIG_fail;
14574 temp2 = true;
14575 }
14576 if (obj2) {
14577 ecode3 = SWIG_AsVal_long(obj2, &val3);
14578 if (!SWIG_IsOK(ecode3)) {
14579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14580 }
14581 arg3 = static_cast< long >(val3);
14582 }
14583 if (obj3) {
14584 ecode4 = SWIG_AsVal_int(obj3, &val4);
14585 if (!SWIG_IsOK(ecode4)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14587 }
14588 arg4 = static_cast< int >(val4);
14589 }
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 {
14597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14598 }
14599 {
14600 if (temp2)
14601 delete arg2;
14602 }
14603 return resultobj;
14604 fail:
14605 {
14606 if (temp2)
14607 delete arg2;
14608 }
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj = 0;
14615 wxImage *arg1 = (wxImage *) 0 ;
14616 wxString *arg2 = 0 ;
14617 wxString *arg3 = 0 ;
14618 int arg4 = (int) -1 ;
14619 bool result;
14620 void *argp1 = 0 ;
14621 int res1 = 0 ;
14622 bool temp2 = false ;
14623 bool temp3 = false ;
14624 int val4 ;
14625 int ecode4 = 0 ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 PyObject * obj2 = 0 ;
14629 PyObject * obj3 = 0 ;
14630 char * kwnames[] = {
14631 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14632 };
14633
14634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14638 }
14639 arg1 = reinterpret_cast< wxImage * >(argp1);
14640 {
14641 arg2 = wxString_in_helper(obj1);
14642 if (arg2 == NULL) SWIG_fail;
14643 temp2 = true;
14644 }
14645 {
14646 arg3 = wxString_in_helper(obj2);
14647 if (arg3 == NULL) SWIG_fail;
14648 temp3 = true;
14649 }
14650 if (obj3) {
14651 ecode4 = SWIG_AsVal_int(obj3, &val4);
14652 if (!SWIG_IsOK(ecode4)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14654 }
14655 arg4 = static_cast< int >(val4);
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 {
14667 if (temp2)
14668 delete arg2;
14669 }
14670 {
14671 if (temp3)
14672 delete arg3;
14673 }
14674 return resultobj;
14675 fail:
14676 {
14677 if (temp2)
14678 delete arg2;
14679 }
14680 {
14681 if (temp3)
14682 delete arg3;
14683 }
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj = 0;
14690 wxImage *arg1 = (wxImage *) 0 ;
14691 wxString *arg2 = 0 ;
14692 int arg3 ;
14693 bool result;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 bool temp2 = false ;
14697 int val3 ;
14698 int ecode3 = 0 ;
14699 PyObject * obj0 = 0 ;
14700 PyObject * obj1 = 0 ;
14701 PyObject * obj2 = 0 ;
14702 char * kwnames[] = {
14703 (char *) "self",(char *) "name",(char *) "type", NULL
14704 };
14705
14706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14708 if (!SWIG_IsOK(res1)) {
14709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14710 }
14711 arg1 = reinterpret_cast< wxImage * >(argp1);
14712 {
14713 arg2 = wxString_in_helper(obj1);
14714 if (arg2 == NULL) SWIG_fail;
14715 temp2 = true;
14716 }
14717 ecode3 = SWIG_AsVal_int(obj2, &val3);
14718 if (!SWIG_IsOK(ecode3)) {
14719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14720 }
14721 arg3 = static_cast< int >(val3);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 {
14729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14730 }
14731 {
14732 if (temp2)
14733 delete arg2;
14734 }
14735 return resultobj;
14736 fail:
14737 {
14738 if (temp2)
14739 delete arg2;
14740 }
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj = 0;
14747 wxImage *arg1 = (wxImage *) 0 ;
14748 wxString *arg2 = 0 ;
14749 wxString *arg3 = 0 ;
14750 bool result;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 bool temp2 = false ;
14754 bool temp3 = false ;
14755 PyObject * obj0 = 0 ;
14756 PyObject * obj1 = 0 ;
14757 PyObject * obj2 = 0 ;
14758 char * kwnames[] = {
14759 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14760 };
14761
14762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14764 if (!SWIG_IsOK(res1)) {
14765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14766 }
14767 arg1 = reinterpret_cast< wxImage * >(argp1);
14768 {
14769 arg2 = wxString_in_helper(obj1);
14770 if (arg2 == NULL) SWIG_fail;
14771 temp2 = true;
14772 }
14773 {
14774 arg3 = wxString_in_helper(obj2);
14775 if (arg3 == NULL) SWIG_fail;
14776 temp3 = true;
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 {
14785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14786 }
14787 {
14788 if (temp2)
14789 delete arg2;
14790 }
14791 {
14792 if (temp3)
14793 delete arg3;
14794 }
14795 return resultobj;
14796 fail:
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 {
14802 if (temp3)
14803 delete arg3;
14804 }
14805 return NULL;
14806 }
14807
14808
14809 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14810 PyObject *resultobj = 0;
14811 wxInputStream *arg1 = 0 ;
14812 bool result;
14813 wxPyInputStream *temp1 ;
14814 bool created1 ;
14815 PyObject * obj0 = 0 ;
14816 char * kwnames[] = {
14817 (char *) "stream", NULL
14818 };
14819
14820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14821 {
14822 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14823 arg1 = temp1->m_wxis;
14824 created1 = false;
14825 } else {
14826 PyErr_Clear(); // clear the failure of the wxPyConvert above
14827 arg1 = wxPyCBInputStream_create(obj0, false);
14828 if (arg1 == NULL) {
14829 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14830 SWIG_fail;
14831 }
14832 created1 = true;
14833 }
14834 }
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (bool)wxImage::CanRead(*arg1);
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14843 }
14844 {
14845 if (created1) delete arg1;
14846 }
14847 return resultobj;
14848 fail:
14849 {
14850 if (created1) delete arg1;
14851 }
14852 return NULL;
14853 }
14854
14855
14856 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14857 PyObject *resultobj = 0;
14858 wxImage *arg1 = (wxImage *) 0 ;
14859 wxInputStream *arg2 = 0 ;
14860 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14861 int arg4 = (int) -1 ;
14862 bool result;
14863 void *argp1 = 0 ;
14864 int res1 = 0 ;
14865 wxPyInputStream *temp2 ;
14866 bool created2 ;
14867 long val3 ;
14868 int ecode3 = 0 ;
14869 int val4 ;
14870 int ecode4 = 0 ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 PyObject * obj3 = 0 ;
14875 char * kwnames[] = {
14876 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14877 };
14878
14879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14881 if (!SWIG_IsOK(res1)) {
14882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14883 }
14884 arg1 = reinterpret_cast< wxImage * >(argp1);
14885 {
14886 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14887 arg2 = temp2->m_wxis;
14888 created2 = false;
14889 } else {
14890 PyErr_Clear(); // clear the failure of the wxPyConvert above
14891 arg2 = wxPyCBInputStream_create(obj1, false);
14892 if (arg2 == NULL) {
14893 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14894 SWIG_fail;
14895 }
14896 created2 = true;
14897 }
14898 }
14899 if (obj2) {
14900 ecode3 = SWIG_AsVal_long(obj2, &val3);
14901 if (!SWIG_IsOK(ecode3)) {
14902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14903 }
14904 arg3 = static_cast< long >(val3);
14905 }
14906 if (obj3) {
14907 ecode4 = SWIG_AsVal_int(obj3, &val4);
14908 if (!SWIG_IsOK(ecode4)) {
14909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14910 }
14911 arg4 = static_cast< int >(val4);
14912 }
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 {
14920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14921 }
14922 {
14923 if (created2) delete arg2;
14924 }
14925 return resultobj;
14926 fail:
14927 {
14928 if (created2) delete arg2;
14929 }
14930 return NULL;
14931 }
14932
14933
14934 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14935 PyObject *resultobj = 0;
14936 wxImage *arg1 = (wxImage *) 0 ;
14937 wxInputStream *arg2 = 0 ;
14938 wxString *arg3 = 0 ;
14939 int arg4 = (int) -1 ;
14940 bool result;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 wxPyInputStream *temp2 ;
14944 bool created2 ;
14945 bool temp3 = false ;
14946 int val4 ;
14947 int ecode4 = 0 ;
14948 PyObject * obj0 = 0 ;
14949 PyObject * obj1 = 0 ;
14950 PyObject * obj2 = 0 ;
14951 PyObject * obj3 = 0 ;
14952 char * kwnames[] = {
14953 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14954 };
14955
14956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14960 }
14961 arg1 = reinterpret_cast< wxImage * >(argp1);
14962 {
14963 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14964 arg2 = temp2->m_wxis;
14965 created2 = false;
14966 } else {
14967 PyErr_Clear(); // clear the failure of the wxPyConvert above
14968 arg2 = wxPyCBInputStream_create(obj1, false);
14969 if (arg2 == NULL) {
14970 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14971 SWIG_fail;
14972 }
14973 created2 = true;
14974 }
14975 }
14976 {
14977 arg3 = wxString_in_helper(obj2);
14978 if (arg3 == NULL) SWIG_fail;
14979 temp3 = true;
14980 }
14981 if (obj3) {
14982 ecode4 = SWIG_AsVal_int(obj3, &val4);
14983 if (!SWIG_IsOK(ecode4)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14985 }
14986 arg4 = static_cast< int >(val4);
14987 }
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 {
14995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14996 }
14997 {
14998 if (created2) delete arg2;
14999 }
15000 {
15001 if (temp3)
15002 delete arg3;
15003 }
15004 return resultobj;
15005 fail:
15006 {
15007 if (created2) delete arg2;
15008 }
15009 {
15010 if (temp3)
15011 delete arg3;
15012 }
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15018 PyObject *resultobj = 0;
15019 wxImage *arg1 = (wxImage *) 0 ;
15020 bool result;
15021 void *argp1 = 0 ;
15022 int res1 = 0 ;
15023 PyObject *swig_obj[1] ;
15024
15025 if (!args) SWIG_fail;
15026 swig_obj[0] = args;
15027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15030 }
15031 arg1 = reinterpret_cast< wxImage * >(argp1);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (bool)(arg1)->Ok();
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 {
15039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15040 }
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 int result;
15051 void *argp1 = 0 ;
15052 int res1 = 0 ;
15053 PyObject *swig_obj[1] ;
15054
15055 if (!args) SWIG_fail;
15056 swig_obj[0] = args;
15057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15058 if (!SWIG_IsOK(res1)) {
15059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15060 }
15061 arg1 = reinterpret_cast< wxImage * >(argp1);
15062 {
15063 PyThreadState* __tstate = wxPyBeginAllowThreads();
15064 result = (int)(arg1)->GetWidth();
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 resultobj = SWIG_From_int(static_cast< int >(result));
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxImage *arg1 = (wxImage *) 0 ;
15078 int result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15088 }
15089 arg1 = reinterpret_cast< wxImage * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (int)(arg1)->GetHeight();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 resultobj = SWIG_From_int(static_cast< int >(result));
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15104 PyObject *resultobj = 0;
15105 wxImage *arg1 = (wxImage *) 0 ;
15106 wxSize result;
15107 void *argp1 = 0 ;
15108 int res1 = 0 ;
15109 PyObject *swig_obj[1] ;
15110
15111 if (!args) SWIG_fail;
15112 swig_obj[0] = args;
15113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15114 if (!SWIG_IsOK(res1)) {
15115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15116 }
15117 arg1 = reinterpret_cast< wxImage * >(argp1);
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 result = wxImage_GetSize(arg1);
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15132 PyObject *resultobj = 0;
15133 wxImage *arg1 = (wxImage *) 0 ;
15134 wxRect *arg2 = 0 ;
15135 SwigValueWrapper<wxImage > result;
15136 void *argp1 = 0 ;
15137 int res1 = 0 ;
15138 wxRect temp2 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 char * kwnames[] = {
15142 (char *) "self",(char *) "rect", NULL
15143 };
15144
15145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15147 if (!SWIG_IsOK(res1)) {
15148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15149 }
15150 arg1 = reinterpret_cast< wxImage * >(argp1);
15151 {
15152 arg2 = &temp2;
15153 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15154 }
15155 {
15156 PyThreadState* __tstate = wxPyBeginAllowThreads();
15157 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15158 wxPyEndAllowThreads(__tstate);
15159 if (PyErr_Occurred()) SWIG_fail;
15160 }
15161 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj = 0;
15170 wxImage *arg1 = (wxImage *) 0 ;
15171 wxSize *arg2 = 0 ;
15172 wxPoint *arg3 = 0 ;
15173 int arg4 = (int) -1 ;
15174 int arg5 = (int) -1 ;
15175 int arg6 = (int) -1 ;
15176 SwigValueWrapper<wxImage > result;
15177 void *argp1 = 0 ;
15178 int res1 = 0 ;
15179 wxSize temp2 ;
15180 wxPoint temp3 ;
15181 int val4 ;
15182 int ecode4 = 0 ;
15183 int val5 ;
15184 int ecode5 = 0 ;
15185 int val6 ;
15186 int ecode6 = 0 ;
15187 PyObject * obj0 = 0 ;
15188 PyObject * obj1 = 0 ;
15189 PyObject * obj2 = 0 ;
15190 PyObject * obj3 = 0 ;
15191 PyObject * obj4 = 0 ;
15192 PyObject * obj5 = 0 ;
15193 char * kwnames[] = {
15194 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15195 };
15196
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15201 }
15202 arg1 = reinterpret_cast< wxImage * >(argp1);
15203 {
15204 arg2 = &temp2;
15205 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15206 }
15207 {
15208 arg3 = &temp3;
15209 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15210 }
15211 if (obj3) {
15212 ecode4 = SWIG_AsVal_int(obj3, &val4);
15213 if (!SWIG_IsOK(ecode4)) {
15214 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15215 }
15216 arg4 = static_cast< int >(val4);
15217 }
15218 if (obj4) {
15219 ecode5 = SWIG_AsVal_int(obj4, &val5);
15220 if (!SWIG_IsOK(ecode5)) {
15221 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15222 }
15223 arg5 = static_cast< int >(val5);
15224 }
15225 if (obj5) {
15226 ecode6 = SWIG_AsVal_int(obj5, &val6);
15227 if (!SWIG_IsOK(ecode6)) {
15228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15229 }
15230 arg6 = static_cast< int >(val6);
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15246 PyObject *resultobj = 0;
15247 wxImage *arg1 = (wxImage *) 0 ;
15248 SwigValueWrapper<wxImage > result;
15249 void *argp1 = 0 ;
15250 int res1 = 0 ;
15251 PyObject *swig_obj[1] ;
15252
15253 if (!args) SWIG_fail;
15254 swig_obj[0] = args;
15255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15256 if (!SWIG_IsOK(res1)) {
15257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15258 }
15259 arg1 = reinterpret_cast< wxImage * >(argp1);
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (arg1)->Copy();
15263 wxPyEndAllowThreads(__tstate);
15264 if (PyErr_Occurred()) SWIG_fail;
15265 }
15266 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15267 return resultobj;
15268 fail:
15269 return NULL;
15270 }
15271
15272
15273 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15274 PyObject *resultobj = 0;
15275 wxImage *arg1 = (wxImage *) 0 ;
15276 wxImage *arg2 = 0 ;
15277 int arg3 ;
15278 int arg4 ;
15279 void *argp1 = 0 ;
15280 int res1 = 0 ;
15281 void *argp2 = 0 ;
15282 int res2 = 0 ;
15283 int val3 ;
15284 int ecode3 = 0 ;
15285 int val4 ;
15286 int ecode4 = 0 ;
15287 PyObject * obj0 = 0 ;
15288 PyObject * obj1 = 0 ;
15289 PyObject * obj2 = 0 ;
15290 PyObject * obj3 = 0 ;
15291 char * kwnames[] = {
15292 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15293 };
15294
15295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15299 }
15300 arg1 = reinterpret_cast< wxImage * >(argp1);
15301 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15302 if (!SWIG_IsOK(res2)) {
15303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15304 }
15305 if (!argp2) {
15306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15307 }
15308 arg2 = reinterpret_cast< wxImage * >(argp2);
15309 ecode3 = SWIG_AsVal_int(obj2, &val3);
15310 if (!SWIG_IsOK(ecode3)) {
15311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15312 }
15313 arg3 = static_cast< int >(val3);
15314 ecode4 = SWIG_AsVal_int(obj3, &val4);
15315 if (!SWIG_IsOK(ecode4)) {
15316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15317 }
15318 arg4 = static_cast< int >(val4);
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_Py_Void();
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15333 PyObject *resultobj = 0;
15334 wxImage *arg1 = (wxImage *) 0 ;
15335 PyObject *result = 0 ;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 PyObject *swig_obj[1] ;
15339
15340 if (!args) SWIG_fail;
15341 swig_obj[0] = args;
15342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15343 if (!SWIG_IsOK(res1)) {
15344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15345 }
15346 arg1 = reinterpret_cast< wxImage * >(argp1);
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (PyObject *)wxImage_GetData(arg1);
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 resultobj = result;
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15361 PyObject *resultobj = 0;
15362 wxImage *arg1 = (wxImage *) 0 ;
15363 buffer arg2 ;
15364 int arg3 ;
15365 void *argp1 = 0 ;
15366 int res1 = 0 ;
15367 PyObject * obj0 = 0 ;
15368 PyObject * obj1 = 0 ;
15369 char * kwnames[] = {
15370 (char *) "self",(char *) "data", NULL
15371 };
15372
15373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15377 }
15378 arg1 = reinterpret_cast< wxImage * >(argp1);
15379 {
15380 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15381 }
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 wxImage_SetData(arg1,arg2,arg3);
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 resultobj = SWIG_Py_Void();
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 PyObject *resultobj = 0;
15397 wxImage *arg1 = (wxImage *) 0 ;
15398 PyObject *result = 0 ;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject *swig_obj[1] ;
15402
15403 if (!args) SWIG_fail;
15404 swig_obj[0] = args;
15405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15408 }
15409 arg1 = reinterpret_cast< wxImage * >(argp1);
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 resultobj = result;
15417 return resultobj;
15418 fail:
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15424 PyObject *resultobj = 0;
15425 wxImage *arg1 = (wxImage *) 0 ;
15426 buffer arg2 ;
15427 int arg3 ;
15428 void *argp1 = 0 ;
15429 int res1 = 0 ;
15430 PyObject * obj0 = 0 ;
15431 PyObject * obj1 = 0 ;
15432 char * kwnames[] = {
15433 (char *) "self",(char *) "data", NULL
15434 };
15435
15436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15438 if (!SWIG_IsOK(res1)) {
15439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15440 }
15441 arg1 = reinterpret_cast< wxImage * >(argp1);
15442 {
15443 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15444 }
15445 {
15446 PyThreadState* __tstate = wxPyBeginAllowThreads();
15447 wxImage_SetDataBuffer(arg1,arg2,arg3);
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 resultobj = SWIG_Py_Void();
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15459 PyObject *resultobj = 0;
15460 wxImage *arg1 = (wxImage *) 0 ;
15461 PyObject *result = 0 ;
15462 void *argp1 = 0 ;
15463 int res1 = 0 ;
15464 PyObject *swig_obj[1] ;
15465
15466 if (!args) SWIG_fail;
15467 swig_obj[0] = args;
15468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15469 if (!SWIG_IsOK(res1)) {
15470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15471 }
15472 arg1 = reinterpret_cast< wxImage * >(argp1);
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (PyObject *)wxImage_GetAlphaData(arg1);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = result;
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxImage *arg1 = (wxImage *) 0 ;
15489 buffer arg2 ;
15490 int arg3 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 char * kwnames[] = {
15496 (char *) "self",(char *) "alpha", NULL
15497 };
15498
15499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15501 if (!SWIG_IsOK(res1)) {
15502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15503 }
15504 arg1 = reinterpret_cast< wxImage * >(argp1);
15505 {
15506 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 wxImage_SetAlphaData(arg1,arg2,arg3);
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_Py_Void();
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15522 PyObject *resultobj = 0;
15523 wxImage *arg1 = (wxImage *) 0 ;
15524 PyObject *result = 0 ;
15525 void *argp1 = 0 ;
15526 int res1 = 0 ;
15527 PyObject *swig_obj[1] ;
15528
15529 if (!args) SWIG_fail;
15530 swig_obj[0] = args;
15531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15534 }
15535 arg1 = reinterpret_cast< wxImage * >(argp1);
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = result;
15543 return resultobj;
15544 fail:
15545 return NULL;
15546 }
15547
15548
15549 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15550 PyObject *resultobj = 0;
15551 wxImage *arg1 = (wxImage *) 0 ;
15552 buffer arg2 ;
15553 int arg3 ;
15554 void *argp1 = 0 ;
15555 int res1 = 0 ;
15556 PyObject * obj0 = 0 ;
15557 PyObject * obj1 = 0 ;
15558 char * kwnames[] = {
15559 (char *) "self",(char *) "alpha", NULL
15560 };
15561
15562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15564 if (!SWIG_IsOK(res1)) {
15565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15566 }
15567 arg1 = reinterpret_cast< wxImage * >(argp1);
15568 {
15569 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15570 }
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_Py_Void();
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15585 PyObject *resultobj = 0;
15586 wxImage *arg1 = (wxImage *) 0 ;
15587 byte arg2 ;
15588 byte arg3 ;
15589 byte arg4 ;
15590 void *argp1 = 0 ;
15591 int res1 = 0 ;
15592 unsigned char val2 ;
15593 int ecode2 = 0 ;
15594 unsigned char val3 ;
15595 int ecode3 = 0 ;
15596 unsigned char val4 ;
15597 int ecode4 = 0 ;
15598 PyObject * obj0 = 0 ;
15599 PyObject * obj1 = 0 ;
15600 PyObject * obj2 = 0 ;
15601 PyObject * obj3 = 0 ;
15602 char * kwnames[] = {
15603 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15604 };
15605
15606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15610 }
15611 arg1 = reinterpret_cast< wxImage * >(argp1);
15612 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15613 if (!SWIG_IsOK(ecode2)) {
15614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15615 }
15616 arg2 = static_cast< byte >(val2);
15617 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15618 if (!SWIG_IsOK(ecode3)) {
15619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15620 }
15621 arg3 = static_cast< byte >(val3);
15622 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15623 if (!SWIG_IsOK(ecode4)) {
15624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15625 }
15626 arg4 = static_cast< byte >(val4);
15627 {
15628 PyThreadState* __tstate = wxPyBeginAllowThreads();
15629 (arg1)->SetMaskColour(arg2,arg3,arg4);
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 resultobj = SWIG_Py_Void();
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15641 PyObject *resultobj = 0;
15642 wxImage *arg1 = (wxImage *) 0 ;
15643 byte *arg2 = (byte *) 0 ;
15644 byte *arg3 = (byte *) 0 ;
15645 byte *arg4 = (byte *) 0 ;
15646 void *argp1 = 0 ;
15647 int res1 = 0 ;
15648 byte temp2 ;
15649 int res2 = SWIG_TMPOBJ ;
15650 byte temp3 ;
15651 int res3 = SWIG_TMPOBJ ;
15652 byte temp4 ;
15653 int res4 = SWIG_TMPOBJ ;
15654 PyObject *swig_obj[1] ;
15655
15656 arg2 = &temp2;
15657 arg3 = &temp3;
15658 arg4 = &temp4;
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15664 }
15665 arg1 = reinterpret_cast< wxImage * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 resultobj = SWIG_Py_Void();
15673 if (SWIG_IsTmpObj(res2)) {
15674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15675 } else {
15676 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15678 }
15679 if (SWIG_IsTmpObj(res3)) {
15680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15681 } else {
15682 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15684 }
15685 if (SWIG_IsTmpObj(res4)) {
15686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15687 } else {
15688 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15690 }
15691 return resultobj;
15692 fail:
15693 return NULL;
15694 }
15695
15696
15697 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15698 PyObject *resultobj = 0;
15699 wxImage *arg1 = (wxImage *) 0 ;
15700 byte result;
15701 void *argp1 = 0 ;
15702 int res1 = 0 ;
15703 PyObject *swig_obj[1] ;
15704
15705 if (!args) SWIG_fail;
15706 swig_obj[0] = args;
15707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15708 if (!SWIG_IsOK(res1)) {
15709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15710 }
15711 arg1 = reinterpret_cast< wxImage * >(argp1);
15712 {
15713 PyThreadState* __tstate = wxPyBeginAllowThreads();
15714 result = (byte)(arg1)->GetMaskRed();
15715 wxPyEndAllowThreads(__tstate);
15716 if (PyErr_Occurred()) SWIG_fail;
15717 }
15718 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15719 return resultobj;
15720 fail:
15721 return NULL;
15722 }
15723
15724
15725 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15726 PyObject *resultobj = 0;
15727 wxImage *arg1 = (wxImage *) 0 ;
15728 byte result;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 PyObject *swig_obj[1] ;
15732
15733 if (!args) SWIG_fail;
15734 swig_obj[0] = args;
15735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15738 }
15739 arg1 = reinterpret_cast< wxImage * >(argp1);
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (byte)(arg1)->GetMaskGreen();
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxImage *arg1 = (wxImage *) 0 ;
15756 byte result;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 PyObject *swig_obj[1] ;
15760
15761 if (!args) SWIG_fail;
15762 swig_obj[0] = args;
15763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (byte)(arg1)->GetMaskBlue();
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 bool arg2 = (bool) true ;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 bool val2 ;
15788 int ecode2 = 0 ;
15789 PyObject * obj0 = 0 ;
15790 PyObject * obj1 = 0 ;
15791 char * kwnames[] = {
15792 (char *) "self",(char *) "mask", NULL
15793 };
15794
15795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15797 if (!SWIG_IsOK(res1)) {
15798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15799 }
15800 arg1 = reinterpret_cast< wxImage * >(argp1);
15801 if (obj1) {
15802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15803 if (!SWIG_IsOK(ecode2)) {
15804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15805 }
15806 arg2 = static_cast< bool >(val2);
15807 }
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 (arg1)->SetMask(arg2);
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_Py_Void();
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxImage *arg1 = (wxImage *) 0 ;
15824 bool result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15834 }
15835 arg1 = reinterpret_cast< wxImage * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (bool)(arg1)->HasMask();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 {
15843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15844 }
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj = 0;
15853 wxImage *arg1 = (wxImage *) 0 ;
15854 double arg2 ;
15855 wxPoint *arg3 = 0 ;
15856 bool arg4 = (bool) true ;
15857 wxPoint *arg5 = (wxPoint *) NULL ;
15858 SwigValueWrapper<wxImage > result;
15859 void *argp1 = 0 ;
15860 int res1 = 0 ;
15861 double val2 ;
15862 int ecode2 = 0 ;
15863 wxPoint temp3 ;
15864 bool val4 ;
15865 int ecode4 = 0 ;
15866 void *argp5 = 0 ;
15867 int res5 = 0 ;
15868 PyObject * obj0 = 0 ;
15869 PyObject * obj1 = 0 ;
15870 PyObject * obj2 = 0 ;
15871 PyObject * obj3 = 0 ;
15872 PyObject * obj4 = 0 ;
15873 char * kwnames[] = {
15874 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15875 };
15876
15877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15879 if (!SWIG_IsOK(res1)) {
15880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15881 }
15882 arg1 = reinterpret_cast< wxImage * >(argp1);
15883 ecode2 = SWIG_AsVal_double(obj1, &val2);
15884 if (!SWIG_IsOK(ecode2)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15886 }
15887 arg2 = static_cast< double >(val2);
15888 {
15889 arg3 = &temp3;
15890 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15891 }
15892 if (obj3) {
15893 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15894 if (!SWIG_IsOK(ecode4)) {
15895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15896 }
15897 arg4 = static_cast< bool >(val4);
15898 }
15899 if (obj4) {
15900 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15901 if (!SWIG_IsOK(res5)) {
15902 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15903 }
15904 arg5 = reinterpret_cast< wxPoint * >(argp5);
15905 }
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15909 wxPyEndAllowThreads(__tstate);
15910 if (PyErr_Occurred()) SWIG_fail;
15911 }
15912 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 wxImage *arg1 = (wxImage *) 0 ;
15922 bool arg2 = (bool) true ;
15923 SwigValueWrapper<wxImage > result;
15924 void *argp1 = 0 ;
15925 int res1 = 0 ;
15926 bool val2 ;
15927 int ecode2 = 0 ;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "self",(char *) "clockwise", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15938 }
15939 arg1 = reinterpret_cast< wxImage * >(argp1);
15940 if (obj1) {
15941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15942 if (!SWIG_IsOK(ecode2)) {
15943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15944 }
15945 arg2 = static_cast< bool >(val2);
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 result = (arg1)->Rotate90(arg2);
15950 wxPyEndAllowThreads(__tstate);
15951 if (PyErr_Occurred()) SWIG_fail;
15952 }
15953 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15961 PyObject *resultobj = 0;
15962 wxImage *arg1 = (wxImage *) 0 ;
15963 bool arg2 = (bool) true ;
15964 SwigValueWrapper<wxImage > result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 bool val2 ;
15968 int ecode2 = 0 ;
15969 PyObject * obj0 = 0 ;
15970 PyObject * obj1 = 0 ;
15971 char * kwnames[] = {
15972 (char *) "self",(char *) "horizontally", NULL
15973 };
15974
15975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15979 }
15980 arg1 = reinterpret_cast< wxImage * >(argp1);
15981 if (obj1) {
15982 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15983 if (!SWIG_IsOK(ecode2)) {
15984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15985 }
15986 arg2 = static_cast< bool >(val2);
15987 }
15988 {
15989 PyThreadState* __tstate = wxPyBeginAllowThreads();
15990 result = (arg1)->Mirror(arg2);
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj = 0;
16003 wxImage *arg1 = (wxImage *) 0 ;
16004 byte arg2 ;
16005 byte arg3 ;
16006 byte arg4 ;
16007 byte arg5 ;
16008 byte arg6 ;
16009 byte arg7 ;
16010 void *argp1 = 0 ;
16011 int res1 = 0 ;
16012 unsigned char val2 ;
16013 int ecode2 = 0 ;
16014 unsigned char val3 ;
16015 int ecode3 = 0 ;
16016 unsigned char val4 ;
16017 int ecode4 = 0 ;
16018 unsigned char val5 ;
16019 int ecode5 = 0 ;
16020 unsigned char val6 ;
16021 int ecode6 = 0 ;
16022 unsigned char val7 ;
16023 int ecode7 = 0 ;
16024 PyObject * obj0 = 0 ;
16025 PyObject * obj1 = 0 ;
16026 PyObject * obj2 = 0 ;
16027 PyObject * obj3 = 0 ;
16028 PyObject * obj4 = 0 ;
16029 PyObject * obj5 = 0 ;
16030 PyObject * obj6 = 0 ;
16031 char * kwnames[] = {
16032 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16033 };
16034
16035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16037 if (!SWIG_IsOK(res1)) {
16038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16039 }
16040 arg1 = reinterpret_cast< wxImage * >(argp1);
16041 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16042 if (!SWIG_IsOK(ecode2)) {
16043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16044 }
16045 arg2 = static_cast< byte >(val2);
16046 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16047 if (!SWIG_IsOK(ecode3)) {
16048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16049 }
16050 arg3 = static_cast< byte >(val3);
16051 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16052 if (!SWIG_IsOK(ecode4)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16054 }
16055 arg4 = static_cast< byte >(val4);
16056 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16057 if (!SWIG_IsOK(ecode5)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16059 }
16060 arg5 = static_cast< byte >(val5);
16061 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16062 if (!SWIG_IsOK(ecode6)) {
16063 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16064 }
16065 arg6 = static_cast< byte >(val6);
16066 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16067 if (!SWIG_IsOK(ecode7)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16069 }
16070 arg7 = static_cast< byte >(val7);
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_Py_Void();
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj = 0;
16086 wxImage *arg1 = (wxImage *) 0 ;
16087 double arg2 = (double) 0.299 ;
16088 double arg3 = (double) 0.587 ;
16089 double arg4 = (double) 0.114 ;
16090 SwigValueWrapper<wxImage > result;
16091 void *argp1 = 0 ;
16092 int res1 = 0 ;
16093 double val2 ;
16094 int ecode2 = 0 ;
16095 double val3 ;
16096 int ecode3 = 0 ;
16097 double val4 ;
16098 int ecode4 = 0 ;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 PyObject * obj2 = 0 ;
16102 PyObject * obj3 = 0 ;
16103 char * kwnames[] = {
16104 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16105 };
16106
16107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16109 if (!SWIG_IsOK(res1)) {
16110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16111 }
16112 arg1 = reinterpret_cast< wxImage * >(argp1);
16113 if (obj1) {
16114 ecode2 = SWIG_AsVal_double(obj1, &val2);
16115 if (!SWIG_IsOK(ecode2)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16117 }
16118 arg2 = static_cast< double >(val2);
16119 }
16120 if (obj2) {
16121 ecode3 = SWIG_AsVal_double(obj2, &val3);
16122 if (!SWIG_IsOK(ecode3)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16124 }
16125 arg3 = static_cast< double >(val3);
16126 }
16127 if (obj3) {
16128 ecode4 = SWIG_AsVal_double(obj3, &val4);
16129 if (!SWIG_IsOK(ecode4)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16131 }
16132 arg4 = static_cast< double >(val4);
16133 }
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16148 PyObject *resultobj = 0;
16149 wxImage *arg1 = (wxImage *) 0 ;
16150 byte arg2 ;
16151 byte arg3 ;
16152 byte arg4 ;
16153 SwigValueWrapper<wxImage > result;
16154 void *argp1 = 0 ;
16155 int res1 = 0 ;
16156 unsigned char val2 ;
16157 int ecode2 = 0 ;
16158 unsigned char val3 ;
16159 int ecode3 = 0 ;
16160 unsigned char val4 ;
16161 int ecode4 = 0 ;
16162 PyObject * obj0 = 0 ;
16163 PyObject * obj1 = 0 ;
16164 PyObject * obj2 = 0 ;
16165 PyObject * obj3 = 0 ;
16166 char * kwnames[] = {
16167 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16168 };
16169
16170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16172 if (!SWIG_IsOK(res1)) {
16173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16174 }
16175 arg1 = reinterpret_cast< wxImage * >(argp1);
16176 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16177 if (!SWIG_IsOK(ecode2)) {
16178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16179 }
16180 arg2 = static_cast< byte >(val2);
16181 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16182 if (!SWIG_IsOK(ecode3)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16184 }
16185 arg3 = static_cast< byte >(val3);
16186 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16187 if (!SWIG_IsOK(ecode4)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16189 }
16190 arg4 = static_cast< byte >(val4);
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 wxString *arg2 = 0 ;
16208 wxString *arg3 = 0 ;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 bool temp2 = false ;
16212 bool temp3 = false ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 PyObject * obj2 = 0 ;
16216 char * kwnames[] = {
16217 (char *) "self",(char *) "name",(char *) "value", NULL
16218 };
16219
16220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16222 if (!SWIG_IsOK(res1)) {
16223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16224 }
16225 arg1 = reinterpret_cast< wxImage * >(argp1);
16226 {
16227 arg2 = wxString_in_helper(obj1);
16228 if (arg2 == NULL) SWIG_fail;
16229 temp2 = true;
16230 }
16231 {
16232 arg3 = wxString_in_helper(obj2);
16233 if (arg3 == NULL) SWIG_fail;
16234 temp3 = true;
16235 }
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 resultobj = SWIG_Py_Void();
16243 {
16244 if (temp2)
16245 delete arg2;
16246 }
16247 {
16248 if (temp3)
16249 delete arg3;
16250 }
16251 return resultobj;
16252 fail:
16253 {
16254 if (temp2)
16255 delete arg2;
16256 }
16257 {
16258 if (temp3)
16259 delete arg3;
16260 }
16261 return NULL;
16262 }
16263
16264
16265 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16266 PyObject *resultobj = 0;
16267 wxImage *arg1 = (wxImage *) 0 ;
16268 wxString *arg2 = 0 ;
16269 int arg3 ;
16270 void *argp1 = 0 ;
16271 int res1 = 0 ;
16272 bool temp2 = false ;
16273 int val3 ;
16274 int ecode3 = 0 ;
16275 PyObject * obj0 = 0 ;
16276 PyObject * obj1 = 0 ;
16277 PyObject * obj2 = 0 ;
16278 char * kwnames[] = {
16279 (char *) "self",(char *) "name",(char *) "value", NULL
16280 };
16281
16282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16284 if (!SWIG_IsOK(res1)) {
16285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16286 }
16287 arg1 = reinterpret_cast< wxImage * >(argp1);
16288 {
16289 arg2 = wxString_in_helper(obj1);
16290 if (arg2 == NULL) SWIG_fail;
16291 temp2 = true;
16292 }
16293 ecode3 = SWIG_AsVal_int(obj2, &val3);
16294 if (!SWIG_IsOK(ecode3)) {
16295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16296 }
16297 arg3 = static_cast< int >(val3);
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 (arg1)->SetOption((wxString const &)*arg2,arg3);
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 resultobj = SWIG_Py_Void();
16305 {
16306 if (temp2)
16307 delete arg2;
16308 }
16309 return resultobj;
16310 fail:
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 return NULL;
16316 }
16317
16318
16319 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj = 0;
16321 wxImage *arg1 = (wxImage *) 0 ;
16322 wxString *arg2 = 0 ;
16323 wxString result;
16324 void *argp1 = 0 ;
16325 int res1 = 0 ;
16326 bool temp2 = false ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "name", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16337 }
16338 arg1 = reinterpret_cast< wxImage * >(argp1);
16339 {
16340 arg2 = wxString_in_helper(obj1);
16341 if (arg2 == NULL) SWIG_fail;
16342 temp2 = true;
16343 }
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 {
16351 #if wxUSE_UNICODE
16352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16353 #else
16354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16355 #endif
16356 }
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return resultobj;
16362 fail:
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxString *arg2 = 0 ;
16375 int result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 bool temp2 = false ;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char * kwnames[] = {
16382 (char *) "self",(char *) "name", NULL
16383 };
16384
16385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16387 if (!SWIG_IsOK(res1)) {
16388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16389 }
16390 arg1 = reinterpret_cast< wxImage * >(argp1);
16391 {
16392 arg2 = wxString_in_helper(obj1);
16393 if (arg2 == NULL) SWIG_fail;
16394 temp2 = true;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 resultobj = SWIG_From_int(static_cast< int >(result));
16403 {
16404 if (temp2)
16405 delete arg2;
16406 }
16407 return resultobj;
16408 fail:
16409 {
16410 if (temp2)
16411 delete arg2;
16412 }
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16418 PyObject *resultobj = 0;
16419 wxImage *arg1 = (wxImage *) 0 ;
16420 wxString *arg2 = 0 ;
16421 bool result;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 bool temp2 = false ;
16425 PyObject * obj0 = 0 ;
16426 PyObject * obj1 = 0 ;
16427 char * kwnames[] = {
16428 (char *) "self",(char *) "name", NULL
16429 };
16430
16431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16433 if (!SWIG_IsOK(res1)) {
16434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16435 }
16436 arg1 = reinterpret_cast< wxImage * >(argp1);
16437 {
16438 arg2 = wxString_in_helper(obj1);
16439 if (arg2 == NULL) SWIG_fail;
16440 temp2 = true;
16441 }
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 {
16449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16450 }
16451 {
16452 if (temp2)
16453 delete arg2;
16454 }
16455 return resultobj;
16456 fail:
16457 {
16458 if (temp2)
16459 delete arg2;
16460 }
16461 return NULL;
16462 }
16463
16464
16465 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj = 0;
16467 wxImage *arg1 = (wxImage *) 0 ;
16468 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16469 unsigned long result;
16470 void *argp1 = 0 ;
16471 int res1 = 0 ;
16472 unsigned long val2 ;
16473 int ecode2 = 0 ;
16474 PyObject * obj0 = 0 ;
16475 PyObject * obj1 = 0 ;
16476 char * kwnames[] = {
16477 (char *) "self",(char *) "stopafter", NULL
16478 };
16479
16480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16482 if (!SWIG_IsOK(res1)) {
16483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16484 }
16485 arg1 = reinterpret_cast< wxImage * >(argp1);
16486 if (obj1) {
16487 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16488 if (!SWIG_IsOK(ecode2)) {
16489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16490 }
16491 arg2 = static_cast< unsigned long >(val2);
16492 }
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (unsigned long)(arg1)->CountColours(arg2);
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj = 0;
16508 wxImage *arg1 = (wxImage *) 0 ;
16509 wxImageHistogram *arg2 = 0 ;
16510 unsigned long result;
16511 void *argp1 = 0 ;
16512 int res1 = 0 ;
16513 void *argp2 = 0 ;
16514 int res2 = 0 ;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char * kwnames[] = {
16518 (char *) "self",(char *) "h", NULL
16519 };
16520
16521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16525 }
16526 arg1 = reinterpret_cast< wxImage * >(argp1);
16527 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16528 if (!SWIG_IsOK(res2)) {
16529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16530 }
16531 if (!argp2) {
16532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16533 }
16534 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16535 {
16536 PyThreadState* __tstate = wxPyBeginAllowThreads();
16537 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16542 return resultobj;
16543 fail:
16544 return NULL;
16545 }
16546
16547
16548 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16549 PyObject *resultobj = 0;
16550 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16551 void *argp1 = 0 ;
16552 int res1 = 0 ;
16553 PyObject * obj0 = 0 ;
16554 char * kwnames[] = {
16555 (char *) "handler", NULL
16556 };
16557
16558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16560 if (!SWIG_IsOK(res1)) {
16561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16562 }
16563 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 wxImage::AddHandler(arg1);
16567 wxPyEndAllowThreads(__tstate);
16568 if (PyErr_Occurred()) SWIG_fail;
16569 }
16570 resultobj = SWIG_Py_Void();
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj = 0;
16579 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 char * kwnames[] = {
16584 (char *) "handler", NULL
16585 };
16586
16587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16591 }
16592 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 wxImage::InsertHandler(arg1);
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 resultobj = SWIG_Py_Void();
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj = 0;
16608 wxString *arg1 = 0 ;
16609 bool result;
16610 bool temp1 = false ;
16611 PyObject * obj0 = 0 ;
16612 char * kwnames[] = {
16613 (char *) "name", NULL
16614 };
16615
16616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16617 {
16618 arg1 = wxString_in_helper(obj0);
16619 if (arg1 == NULL) SWIG_fail;
16620 temp1 = true;
16621 }
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16630 }
16631 {
16632 if (temp1)
16633 delete arg1;
16634 }
16635 return resultobj;
16636 fail:
16637 {
16638 if (temp1)
16639 delete arg1;
16640 }
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16646 PyObject *resultobj = 0;
16647 PyObject *result = 0 ;
16648
16649 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 result = (PyObject *)wxImage_GetHandlers();
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 resultobj = result;
16657 return resultobj;
16658 fail:
16659 return NULL;
16660 }
16661
16662
16663 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16664 PyObject *resultobj = 0;
16665 wxString result;
16666
16667 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16668 {
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 result = wxImage::GetImageExtWildcard();
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 {
16675 #if wxUSE_UNICODE
16676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16677 #else
16678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16679 #endif
16680 }
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj = 0;
16689 wxImage *arg1 = (wxImage *) 0 ;
16690 int arg2 = (int) -1 ;
16691 wxBitmap result;
16692 void *argp1 = 0 ;
16693 int res1 = 0 ;
16694 int val2 ;
16695 int ecode2 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 char * kwnames[] = {
16699 (char *) "self",(char *) "depth", NULL
16700 };
16701
16702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16706 }
16707 arg1 = reinterpret_cast< wxImage * >(argp1);
16708 if (obj1) {
16709 ecode2 = SWIG_AsVal_int(obj1, &val2);
16710 if (!SWIG_IsOK(ecode2)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16712 }
16713 arg2 = static_cast< int >(val2);
16714 }
16715 {
16716 if (!wxPyCheckForApp()) SWIG_fail;
16717 PyThreadState* __tstate = wxPyBeginAllowThreads();
16718 result = wxImage_ConvertToBitmap(arg1,arg2);
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16723 return resultobj;
16724 fail:
16725 return NULL;
16726 }
16727
16728
16729 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16730 PyObject *resultobj = 0;
16731 wxImage *arg1 = (wxImage *) 0 ;
16732 byte arg2 ;
16733 byte arg3 ;
16734 byte arg4 ;
16735 wxBitmap result;
16736 void *argp1 = 0 ;
16737 int res1 = 0 ;
16738 unsigned char val2 ;
16739 int ecode2 = 0 ;
16740 unsigned char val3 ;
16741 int ecode3 = 0 ;
16742 unsigned char val4 ;
16743 int ecode4 = 0 ;
16744 PyObject * obj0 = 0 ;
16745 PyObject * obj1 = 0 ;
16746 PyObject * obj2 = 0 ;
16747 PyObject * obj3 = 0 ;
16748 char * kwnames[] = {
16749 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16750 };
16751
16752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16754 if (!SWIG_IsOK(res1)) {
16755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16756 }
16757 arg1 = reinterpret_cast< wxImage * >(argp1);
16758 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16759 if (!SWIG_IsOK(ecode2)) {
16760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16761 }
16762 arg2 = static_cast< byte >(val2);
16763 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16764 if (!SWIG_IsOK(ecode3)) {
16765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16766 }
16767 arg3 = static_cast< byte >(val3);
16768 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16769 if (!SWIG_IsOK(ecode4)) {
16770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16771 }
16772 arg4 = static_cast< byte >(val4);
16773 {
16774 if (!wxPyCheckForApp()) SWIG_fail;
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj = 0;
16789 wxImage *arg1 = (wxImage *) 0 ;
16790 double arg2 ;
16791 void *argp1 = 0 ;
16792 int res1 = 0 ;
16793 double val2 ;
16794 int ecode2 = 0 ;
16795 PyObject * obj0 = 0 ;
16796 PyObject * obj1 = 0 ;
16797 char * kwnames[] = {
16798 (char *) "self",(char *) "angle", NULL
16799 };
16800
16801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16803 if (!SWIG_IsOK(res1)) {
16804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16805 }
16806 arg1 = reinterpret_cast< wxImage * >(argp1);
16807 ecode2 = SWIG_AsVal_double(obj1, &val2);
16808 if (!SWIG_IsOK(ecode2)) {
16809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16810 }
16811 arg2 = static_cast< double >(val2);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 (arg1)->RotateHue(arg2);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 resultobj = SWIG_Py_Void();
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj = 0;
16827 wxImage_RGBValue arg1 ;
16828 wxImage_HSVValue result;
16829 void *argp1 ;
16830 int res1 = 0 ;
16831 PyObject * obj0 = 0 ;
16832 char * kwnames[] = {
16833 (char *) "rgb", NULL
16834 };
16835
16836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16837 {
16838 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16839 if (!SWIG_IsOK(res1)) {
16840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16841 }
16842 if (!argp1) {
16843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16844 } else {
16845 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16846 arg1 = *temp;
16847 if (SWIG_IsNewObj(res1)) delete temp;
16848 }
16849 }
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = wxImage::RGBtoHSV(arg1);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxImage_HSVValue arg1 ;
16866 wxImage_RGBValue result;
16867 void *argp1 ;
16868 int res1 = 0 ;
16869 PyObject * obj0 = 0 ;
16870 char * kwnames[] = {
16871 (char *) "hsv", NULL
16872 };
16873
16874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16875 {
16876 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16877 if (!SWIG_IsOK(res1)) {
16878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16879 }
16880 if (!argp1) {
16881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16882 } else {
16883 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16884 arg1 = *temp;
16885 if (SWIG_IsNewObj(res1)) delete temp;
16886 }
16887 }
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = wxImage::HSVtoRGB(arg1);
16891 wxPyEndAllowThreads(__tstate);
16892 if (PyErr_Occurred()) SWIG_fail;
16893 }
16894 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16895 return resultobj;
16896 fail:
16897 return NULL;
16898 }
16899
16900
16901 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16902 PyObject *obj;
16903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16904 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16905 return SWIG_Py_Void();
16906 }
16907
16908 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16909 return SWIG_Python_InitShadowInstance(args);
16910 }
16911
16912 SWIGINTERN int NullImage_set(PyObject *) {
16913 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16914 return 1;
16915 }
16916
16917
16918 SWIGINTERN PyObject *NullImage_get(void) {
16919 PyObject *pyobj = 0;
16920
16921 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16922 return pyobj;
16923 }
16924
16925
16926 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16928 return 1;
16929 }
16930
16931
16932 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16933 PyObject *pyobj = 0;
16934
16935 {
16936 #if wxUSE_UNICODE
16937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16938 #else
16939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16940 #endif
16941 }
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17087 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17088 return 1;
17089 }
17090
17091
17092 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17093 PyObject *pyobj = 0;
17094
17095 {
17096 #if wxUSE_UNICODE
17097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17098 #else
17099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17100 #endif
17101 }
17102 return pyobj;
17103 }
17104
17105
17106 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17107 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17108 return 1;
17109 }
17110
17111
17112 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17113 PyObject *pyobj = 0;
17114
17115 {
17116 #if wxUSE_UNICODE
17117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17118 #else
17119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17120 #endif
17121 }
17122 return pyobj;
17123 }
17124
17125
17126 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17127 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17128 return 1;
17129 }
17130
17131
17132 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17133 PyObject *pyobj = 0;
17134
17135 {
17136 #if wxUSE_UNICODE
17137 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17138 #else
17139 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17140 #endif
17141 }
17142 return pyobj;
17143 }
17144
17145
17146 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17147 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17148 return 1;
17149 }
17150
17151
17152 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17153 PyObject *pyobj = 0;
17154
17155 {
17156 #if wxUSE_UNICODE
17157 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17158 #else
17159 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17160 #endif
17161 }
17162 return pyobj;
17163 }
17164
17165
17166 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17167 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17168 return 1;
17169 }
17170
17171
17172 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17173 PyObject *pyobj = 0;
17174
17175 {
17176 #if wxUSE_UNICODE
17177 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17178 #else
17179 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17180 #endif
17181 }
17182 return pyobj;
17183 }
17184
17185
17186 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17187 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17188 return 1;
17189 }
17190
17191
17192 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17193 PyObject *pyobj = 0;
17194
17195 {
17196 #if wxUSE_UNICODE
17197 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17198 #else
17199 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17200 #endif
17201 }
17202 return pyobj;
17203 }
17204
17205
17206 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17207 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17208 return 1;
17209 }
17210
17211
17212 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17213 PyObject *pyobj = 0;
17214
17215 {
17216 #if wxUSE_UNICODE
17217 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17218 #else
17219 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17220 #endif
17221 }
17222 return pyobj;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17227 PyObject *resultobj = 0;
17228 wxBMPHandler *result = 0 ;
17229
17230 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (wxBMPHandler *)new wxBMPHandler();
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17245 PyObject *obj;
17246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17247 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17248 return SWIG_Py_Void();
17249 }
17250
17251 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17252 return SWIG_Python_InitShadowInstance(args);
17253 }
17254
17255 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17256 PyObject *resultobj = 0;
17257 wxICOHandler *result = 0 ;
17258
17259 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17260 {
17261 PyThreadState* __tstate = wxPyBeginAllowThreads();
17262 result = (wxICOHandler *)new wxICOHandler();
17263 wxPyEndAllowThreads(__tstate);
17264 if (PyErr_Occurred()) SWIG_fail;
17265 }
17266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17267 return resultobj;
17268 fail:
17269 return NULL;
17270 }
17271
17272
17273 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17274 PyObject *obj;
17275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17276 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17277 return SWIG_Py_Void();
17278 }
17279
17280 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17281 return SWIG_Python_InitShadowInstance(args);
17282 }
17283
17284 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17285 PyObject *resultobj = 0;
17286 wxCURHandler *result = 0 ;
17287
17288 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = (wxCURHandler *)new wxCURHandler();
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17296 return resultobj;
17297 fail:
17298 return NULL;
17299 }
17300
17301
17302 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17303 PyObject *obj;
17304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17305 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17306 return SWIG_Py_Void();
17307 }
17308
17309 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17310 return SWIG_Python_InitShadowInstance(args);
17311 }
17312
17313 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 PyObject *resultobj = 0;
17315 wxANIHandler *result = 0 ;
17316
17317 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 result = (wxANIHandler *)new wxANIHandler();
17321 wxPyEndAllowThreads(__tstate);
17322 if (PyErr_Occurred()) SWIG_fail;
17323 }
17324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17325 return resultobj;
17326 fail:
17327 return NULL;
17328 }
17329
17330
17331 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17332 PyObject *obj;
17333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17334 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17335 return SWIG_Py_Void();
17336 }
17337
17338 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17339 return SWIG_Python_InitShadowInstance(args);
17340 }
17341
17342 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17343 PyObject *resultobj = 0;
17344 wxPNGHandler *result = 0 ;
17345
17346 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (wxPNGHandler *)new wxPNGHandler();
17350 wxPyEndAllowThreads(__tstate);
17351 if (PyErr_Occurred()) SWIG_fail;
17352 }
17353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17361 PyObject *obj;
17362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17363 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17364 return SWIG_Py_Void();
17365 }
17366
17367 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17368 return SWIG_Python_InitShadowInstance(args);
17369 }
17370
17371 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 PyObject *resultobj = 0;
17373 wxGIFHandler *result = 0 ;
17374
17375 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17376 {
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = (wxGIFHandler *)new wxGIFHandler();
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17390 PyObject *obj;
17391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17392 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17393 return SWIG_Py_Void();
17394 }
17395
17396 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 return SWIG_Python_InitShadowInstance(args);
17398 }
17399
17400 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17401 PyObject *resultobj = 0;
17402 wxPCXHandler *result = 0 ;
17403
17404 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17405 {
17406 PyThreadState* __tstate = wxPyBeginAllowThreads();
17407 result = (wxPCXHandler *)new wxPCXHandler();
17408 wxPyEndAllowThreads(__tstate);
17409 if (PyErr_Occurred()) SWIG_fail;
17410 }
17411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17412 return resultobj;
17413 fail:
17414 return NULL;
17415 }
17416
17417
17418 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17419 PyObject *obj;
17420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17421 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17422 return SWIG_Py_Void();
17423 }
17424
17425 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17426 return SWIG_Python_InitShadowInstance(args);
17427 }
17428
17429 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 PyObject *resultobj = 0;
17431 wxJPEGHandler *result = 0 ;
17432
17433 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17434 {
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 result = (wxJPEGHandler *)new wxJPEGHandler();
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17448 PyObject *obj;
17449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17450 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17451 return SWIG_Py_Void();
17452 }
17453
17454 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17455 return SWIG_Python_InitShadowInstance(args);
17456 }
17457
17458 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 PyObject *resultobj = 0;
17460 wxPNMHandler *result = 0 ;
17461
17462 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17463 {
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = (wxPNMHandler *)new wxPNMHandler();
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17470 return resultobj;
17471 fail:
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 PyObject *obj;
17478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17479 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17480 return SWIG_Py_Void();
17481 }
17482
17483 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17484 return SWIG_Python_InitShadowInstance(args);
17485 }
17486
17487 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 PyObject *resultobj = 0;
17489 wxXPMHandler *result = 0 ;
17490
17491 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17492 {
17493 PyThreadState* __tstate = wxPyBeginAllowThreads();
17494 result = (wxXPMHandler *)new wxXPMHandler();
17495 wxPyEndAllowThreads(__tstate);
17496 if (PyErr_Occurred()) SWIG_fail;
17497 }
17498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17499 return resultobj;
17500 fail:
17501 return NULL;
17502 }
17503
17504
17505 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17506 PyObject *obj;
17507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17508 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17509 return SWIG_Py_Void();
17510 }
17511
17512 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17513 return SWIG_Python_InitShadowInstance(args);
17514 }
17515
17516 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 PyObject *resultobj = 0;
17518 wxTIFFHandler *result = 0 ;
17519
17520 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (wxTIFFHandler *)new wxTIFFHandler();
17524 wxPyEndAllowThreads(__tstate);
17525 if (PyErr_Occurred()) SWIG_fail;
17526 }
17527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17528 return resultobj;
17529 fail:
17530 return NULL;
17531 }
17532
17533
17534 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17535 PyObject *obj;
17536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17537 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17538 return SWIG_Py_Void();
17539 }
17540
17541 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17542 return SWIG_Python_InitShadowInstance(args);
17543 }
17544
17545 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17546 PyObject *resultobj = 0;
17547 wxImage *arg1 = 0 ;
17548 wxImage *arg2 = 0 ;
17549 int arg3 = (int) 236 ;
17550 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17551 bool result;
17552 void *argp1 = 0 ;
17553 int res1 = 0 ;
17554 void *argp2 = 0 ;
17555 int res2 = 0 ;
17556 int val3 ;
17557 int ecode3 = 0 ;
17558 int val4 ;
17559 int ecode4 = 0 ;
17560 PyObject * obj0 = 0 ;
17561 PyObject * obj1 = 0 ;
17562 PyObject * obj2 = 0 ;
17563 PyObject * obj3 = 0 ;
17564 char * kwnames[] = {
17565 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17566 };
17567
17568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17569 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17570 if (!SWIG_IsOK(res1)) {
17571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17572 }
17573 if (!argp1) {
17574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17575 }
17576 arg1 = reinterpret_cast< wxImage * >(argp1);
17577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17578 if (!SWIG_IsOK(res2)) {
17579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17580 }
17581 if (!argp2) {
17582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17583 }
17584 arg2 = reinterpret_cast< wxImage * >(argp2);
17585 if (obj2) {
17586 ecode3 = SWIG_AsVal_int(obj2, &val3);
17587 if (!SWIG_IsOK(ecode3)) {
17588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17589 }
17590 arg3 = static_cast< int >(val3);
17591 }
17592 if (obj3) {
17593 ecode4 = SWIG_AsVal_int(obj3, &val4);
17594 if (!SWIG_IsOK(ecode4)) {
17595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17596 }
17597 arg4 = static_cast< int >(val4);
17598 }
17599 {
17600 PyThreadState* __tstate = wxPyBeginAllowThreads();
17601 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17602 wxPyEndAllowThreads(__tstate);
17603 if (PyErr_Occurred()) SWIG_fail;
17604 }
17605 {
17606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17607 }
17608 return resultobj;
17609 fail:
17610 return NULL;
17611 }
17612
17613
17614 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17615 PyObject *obj;
17616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17617 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17618 return SWIG_Py_Void();
17619 }
17620
17621 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17622 PyObject *resultobj = 0;
17623 wxEvtHandler *result = 0 ;
17624
17625 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17626 {
17627 PyThreadState* __tstate = wxPyBeginAllowThreads();
17628 result = (wxEvtHandler *)new wxEvtHandler();
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17640 PyObject *resultobj = 0;
17641 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17642 wxEvtHandler *result = 0 ;
17643 void *argp1 = 0 ;
17644 int res1 = 0 ;
17645 PyObject *swig_obj[1] ;
17646
17647 if (!args) SWIG_fail;
17648 swig_obj[0] = args;
17649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17650 if (!SWIG_IsOK(res1)) {
17651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17652 }
17653 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 {
17661 resultobj = wxPyMake_wxObject(result, 0);
17662 }
17663 return resultobj;
17664 fail:
17665 return NULL;
17666 }
17667
17668
17669 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17670 PyObject *resultobj = 0;
17671 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17672 wxEvtHandler *result = 0 ;
17673 void *argp1 = 0 ;
17674 int res1 = 0 ;
17675 PyObject *swig_obj[1] ;
17676
17677 if (!args) SWIG_fail;
17678 swig_obj[0] = args;
17679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17680 if (!SWIG_IsOK(res1)) {
17681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17682 }
17683 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 {
17691 resultobj = wxPyMake_wxObject(result, 0);
17692 }
17693 return resultobj;
17694 fail:
17695 return NULL;
17696 }
17697
17698
17699 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17700 PyObject *resultobj = 0;
17701 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17702 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17703 void *argp1 = 0 ;
17704 int res1 = 0 ;
17705 void *argp2 = 0 ;
17706 int res2 = 0 ;
17707 PyObject * obj0 = 0 ;
17708 PyObject * obj1 = 0 ;
17709 char * kwnames[] = {
17710 (char *) "self",(char *) "handler", NULL
17711 };
17712
17713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17715 if (!SWIG_IsOK(res1)) {
17716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17717 }
17718 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17720 if (!SWIG_IsOK(res2)) {
17721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17722 }
17723 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17724 {
17725 PyThreadState* __tstate = wxPyBeginAllowThreads();
17726 (arg1)->SetNextHandler(arg2);
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 resultobj = SWIG_Py_Void();
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj = 0;
17739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17740 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17741 void *argp1 = 0 ;
17742 int res1 = 0 ;
17743 void *argp2 = 0 ;
17744 int res2 = 0 ;
17745 PyObject * obj0 = 0 ;
17746 PyObject * obj1 = 0 ;
17747 char * kwnames[] = {
17748 (char *) "self",(char *) "handler", NULL
17749 };
17750
17751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17753 if (!SWIG_IsOK(res1)) {
17754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17755 }
17756 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17758 if (!SWIG_IsOK(res2)) {
17759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17760 }
17761 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 (arg1)->SetPreviousHandler(arg2);
17765 wxPyEndAllowThreads(__tstate);
17766 if (PyErr_Occurred()) SWIG_fail;
17767 }
17768 resultobj = SWIG_Py_Void();
17769 return resultobj;
17770 fail:
17771 return NULL;
17772 }
17773
17774
17775 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17776 PyObject *resultobj = 0;
17777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17778 bool result;
17779 void *argp1 = 0 ;
17780 int res1 = 0 ;
17781 PyObject *swig_obj[1] ;
17782
17783 if (!args) SWIG_fail;
17784 swig_obj[0] = args;
17785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17786 if (!SWIG_IsOK(res1)) {
17787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17788 }
17789 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)(arg1)->GetEvtHandlerEnabled();
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17798 }
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj = 0;
17807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17808 bool arg2 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 bool val2 ;
17812 int ecode2 = 0 ;
17813 PyObject * obj0 = 0 ;
17814 PyObject * obj1 = 0 ;
17815 char * kwnames[] = {
17816 (char *) "self",(char *) "enabled", NULL
17817 };
17818
17819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17823 }
17824 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17826 if (!SWIG_IsOK(ecode2)) {
17827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17828 }
17829 arg2 = static_cast< bool >(val2);
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 (arg1)->SetEvtHandlerEnabled(arg2);
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = SWIG_Py_Void();
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 wxEvent *arg2 = 0 ;
17847 bool result;
17848 void *argp1 = 0 ;
17849 int res1 = 0 ;
17850 void *argp2 = 0 ;
17851 int res2 = 0 ;
17852 PyObject * obj0 = 0 ;
17853 PyObject * obj1 = 0 ;
17854 char * kwnames[] = {
17855 (char *) "self",(char *) "event", NULL
17856 };
17857
17858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17860 if (!SWIG_IsOK(res1)) {
17861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17862 }
17863 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17865 if (!SWIG_IsOK(res2)) {
17866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17867 }
17868 if (!argp2) {
17869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17870 }
17871 arg2 = reinterpret_cast< wxEvent * >(argp2);
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (bool)(arg1)->ProcessEvent(*arg2);
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 {
17879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17880 }
17881 return resultobj;
17882 fail:
17883 return NULL;
17884 }
17885
17886
17887 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17888 PyObject *resultobj = 0;
17889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17890 wxEvent *arg2 = 0 ;
17891 void *argp1 = 0 ;
17892 int res1 = 0 ;
17893 void *argp2 = 0 ;
17894 int res2 = 0 ;
17895 PyObject * obj0 = 0 ;
17896 PyObject * obj1 = 0 ;
17897 char * kwnames[] = {
17898 (char *) "self",(char *) "event", NULL
17899 };
17900
17901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17903 if (!SWIG_IsOK(res1)) {
17904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17905 }
17906 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17908 if (!SWIG_IsOK(res2)) {
17909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17910 }
17911 if (!argp2) {
17912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17913 }
17914 arg2 = reinterpret_cast< wxEvent * >(argp2);
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 (arg1)->AddPendingEvent(*arg2);
17918 wxPyEndAllowThreads(__tstate);
17919 if (PyErr_Occurred()) SWIG_fail;
17920 }
17921 resultobj = SWIG_Py_Void();
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17929 PyObject *resultobj = 0;
17930 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 PyObject *swig_obj[1] ;
17934
17935 if (!args) SWIG_fail;
17936 swig_obj[0] = args;
17937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17938 if (!SWIG_IsOK(res1)) {
17939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17940 }
17941 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 (arg1)->ProcessPendingEvents();
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_Py_Void();
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = 0;
17957 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17958 int arg2 ;
17959 int arg3 ;
17960 int arg4 ;
17961 PyObject *arg5 = (PyObject *) 0 ;
17962 void *argp1 = 0 ;
17963 int res1 = 0 ;
17964 int val2 ;
17965 int ecode2 = 0 ;
17966 int val3 ;
17967 int ecode3 = 0 ;
17968 int val4 ;
17969 int ecode4 = 0 ;
17970 PyObject * obj0 = 0 ;
17971 PyObject * obj1 = 0 ;
17972 PyObject * obj2 = 0 ;
17973 PyObject * obj3 = 0 ;
17974 PyObject * obj4 = 0 ;
17975 char * kwnames[] = {
17976 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17977 };
17978
17979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17981 if (!SWIG_IsOK(res1)) {
17982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17983 }
17984 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17985 ecode2 = SWIG_AsVal_int(obj1, &val2);
17986 if (!SWIG_IsOK(ecode2)) {
17987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17988 }
17989 arg2 = static_cast< int >(val2);
17990 ecode3 = SWIG_AsVal_int(obj2, &val3);
17991 if (!SWIG_IsOK(ecode3)) {
17992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17993 }
17994 arg3 = static_cast< int >(val3);
17995 ecode4 = SWIG_AsVal_int(obj3, &val4);
17996 if (!SWIG_IsOK(ecode4)) {
17997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17998 }
17999 arg4 = static_cast< int >(val4);
18000 arg5 = obj4;
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 resultobj = SWIG_Py_Void();
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj = 0;
18016 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18017 int arg2 ;
18018 int arg3 = (int) -1 ;
18019 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18020 bool result;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 int val2 ;
18024 int ecode2 = 0 ;
18025 int val3 ;
18026 int ecode3 = 0 ;
18027 int val4 ;
18028 int ecode4 = 0 ;
18029 PyObject * obj0 = 0 ;
18030 PyObject * obj1 = 0 ;
18031 PyObject * obj2 = 0 ;
18032 PyObject * obj3 = 0 ;
18033 char * kwnames[] = {
18034 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18035 };
18036
18037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18039 if (!SWIG_IsOK(res1)) {
18040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18041 }
18042 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18043 ecode2 = SWIG_AsVal_int(obj1, &val2);
18044 if (!SWIG_IsOK(ecode2)) {
18045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18046 }
18047 arg2 = static_cast< int >(val2);
18048 if (obj2) {
18049 ecode3 = SWIG_AsVal_int(obj2, &val3);
18050 if (!SWIG_IsOK(ecode3)) {
18051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18052 }
18053 arg3 = static_cast< int >(val3);
18054 }
18055 if (obj3) {
18056 ecode4 = SWIG_AsVal_int(obj3, &val4);
18057 if (!SWIG_IsOK(ecode4)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18059 }
18060 arg4 = static_cast< wxEventType >(val4);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 {
18069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18070 }
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj = 0;
18079 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18080 PyObject *arg2 = (PyObject *) 0 ;
18081 bool arg3 = (bool) true ;
18082 void *argp1 = 0 ;
18083 int res1 = 0 ;
18084 bool val3 ;
18085 int ecode3 = 0 ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 PyObject * obj2 = 0 ;
18089 char * kwnames[] = {
18090 (char *) "self",(char *) "_self",(char *) "incref", NULL
18091 };
18092
18093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18095 if (!SWIG_IsOK(res1)) {
18096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18097 }
18098 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18099 arg2 = obj1;
18100 if (obj2) {
18101 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18102 if (!SWIG_IsOK(ecode3)) {
18103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18104 }
18105 arg3 = static_cast< bool >(val3);
18106 }
18107 {
18108 PyThreadState* __tstate = wxPyBeginAllowThreads();
18109 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 resultobj = SWIG_Py_Void();
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18121 PyObject *obj;
18122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18123 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18124 return SWIG_Py_Void();
18125 }
18126
18127 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18128 return SWIG_Python_InitShadowInstance(args);
18129 }
18130
18131 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 PyObject *resultobj = 0;
18133 wxEventType result;
18134
18135 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (wxEventType)wxNewEventType();
18139 wxPyEndAllowThreads(__tstate);
18140 if (PyErr_Occurred()) SWIG_fail;
18141 }
18142 resultobj = SWIG_From_int(static_cast< int >(result));
18143 return resultobj;
18144 fail:
18145 return NULL;
18146 }
18147
18148
18149 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18150 PyObject *resultobj = 0;
18151 wxEvent *arg1 = (wxEvent *) 0 ;
18152 void *argp1 = 0 ;
18153 int res1 = 0 ;
18154 PyObject *swig_obj[1] ;
18155
18156 if (!args) SWIG_fail;
18157 swig_obj[0] = args;
18158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18159 if (!SWIG_IsOK(res1)) {
18160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18161 }
18162 arg1 = reinterpret_cast< wxEvent * >(argp1);
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 delete arg1;
18166
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 resultobj = SWIG_Py_Void();
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18178 PyObject *resultobj = 0;
18179 wxEvent *arg1 = (wxEvent *) 0 ;
18180 wxEventType arg2 ;
18181 void *argp1 = 0 ;
18182 int res1 = 0 ;
18183 int val2 ;
18184 int ecode2 = 0 ;
18185 PyObject * obj0 = 0 ;
18186 PyObject * obj1 = 0 ;
18187 char * kwnames[] = {
18188 (char *) "self",(char *) "typ", NULL
18189 };
18190
18191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18195 }
18196 arg1 = reinterpret_cast< wxEvent * >(argp1);
18197 ecode2 = SWIG_AsVal_int(obj1, &val2);
18198 if (!SWIG_IsOK(ecode2)) {
18199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18200 }
18201 arg2 = static_cast< wxEventType >(val2);
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 (arg1)->SetEventType(arg2);
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 resultobj = SWIG_Py_Void();
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18216 PyObject *resultobj = 0;
18217 wxEvent *arg1 = (wxEvent *) 0 ;
18218 wxEventType result;
18219 void *argp1 = 0 ;
18220 int res1 = 0 ;
18221 PyObject *swig_obj[1] ;
18222
18223 if (!args) SWIG_fail;
18224 swig_obj[0] = args;
18225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 resultobj = SWIG_From_int(static_cast< int >(result));
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18244 PyObject *resultobj = 0;
18245 wxEvent *arg1 = (wxEvent *) 0 ;
18246 wxObject *result = 0 ;
18247 void *argp1 = 0 ;
18248 int res1 = 0 ;
18249 PyObject *swig_obj[1] ;
18250
18251 if (!args) SWIG_fail;
18252 swig_obj[0] = args;
18253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18254 if (!SWIG_IsOK(res1)) {
18255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18256 }
18257 arg1 = reinterpret_cast< wxEvent * >(argp1);
18258 {
18259 PyThreadState* __tstate = wxPyBeginAllowThreads();
18260 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18261 wxPyEndAllowThreads(__tstate);
18262 if (PyErr_Occurred()) SWIG_fail;
18263 }
18264 {
18265 resultobj = wxPyMake_wxObject(result, (bool)0);
18266 }
18267 return resultobj;
18268 fail:
18269 return NULL;
18270 }
18271
18272
18273 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj = 0;
18275 wxEvent *arg1 = (wxEvent *) 0 ;
18276 wxObject *arg2 = (wxObject *) 0 ;
18277 void *argp1 = 0 ;
18278 int res1 = 0 ;
18279 void *argp2 = 0 ;
18280 int res2 = 0 ;
18281 PyObject * obj0 = 0 ;
18282 PyObject * obj1 = 0 ;
18283 char * kwnames[] = {
18284 (char *) "self",(char *) "obj", NULL
18285 };
18286
18287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18289 if (!SWIG_IsOK(res1)) {
18290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18291 }
18292 arg1 = reinterpret_cast< wxEvent * >(argp1);
18293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18294 if (!SWIG_IsOK(res2)) {
18295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18296 }
18297 arg2 = reinterpret_cast< wxObject * >(argp2);
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 (arg1)->SetEventObject(arg2);
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = SWIG_Py_Void();
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18312 PyObject *resultobj = 0;
18313 wxEvent *arg1 = (wxEvent *) 0 ;
18314 long result;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 PyObject *swig_obj[1] ;
18318
18319 if (!args) SWIG_fail;
18320 swig_obj[0] = args;
18321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18324 }
18325 arg1 = reinterpret_cast< wxEvent * >(argp1);
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 resultobj = SWIG_From_long(static_cast< long >(result));
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj = 0;
18341 wxEvent *arg1 = (wxEvent *) 0 ;
18342 long arg2 = (long) 0 ;
18343 void *argp1 = 0 ;
18344 int res1 = 0 ;
18345 long val2 ;
18346 int ecode2 = 0 ;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char * kwnames[] = {
18350 (char *) "self",(char *) "ts", NULL
18351 };
18352
18353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18355 if (!SWIG_IsOK(res1)) {
18356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18357 }
18358 arg1 = reinterpret_cast< wxEvent * >(argp1);
18359 if (obj1) {
18360 ecode2 = SWIG_AsVal_long(obj1, &val2);
18361 if (!SWIG_IsOK(ecode2)) {
18362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18363 }
18364 arg2 = static_cast< long >(val2);
18365 }
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 (arg1)->SetTimestamp(arg2);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = SWIG_Py_Void();
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18380 PyObject *resultobj = 0;
18381 wxEvent *arg1 = (wxEvent *) 0 ;
18382 int result;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 PyObject *swig_obj[1] ;
18386
18387 if (!args) SWIG_fail;
18388 swig_obj[0] = args;
18389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18390 if (!SWIG_IsOK(res1)) {
18391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18392 }
18393 arg1 = reinterpret_cast< wxEvent * >(argp1);
18394 {
18395 PyThreadState* __tstate = wxPyBeginAllowThreads();
18396 result = (int)((wxEvent const *)arg1)->GetId();
18397 wxPyEndAllowThreads(__tstate);
18398 if (PyErr_Occurred()) SWIG_fail;
18399 }
18400 resultobj = SWIG_From_int(static_cast< int >(result));
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj = 0;
18409 wxEvent *arg1 = (wxEvent *) 0 ;
18410 int arg2 ;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 int val2 ;
18414 int ecode2 = 0 ;
18415 PyObject * obj0 = 0 ;
18416 PyObject * obj1 = 0 ;
18417 char * kwnames[] = {
18418 (char *) "self",(char *) "Id", NULL
18419 };
18420
18421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 ecode2 = SWIG_AsVal_int(obj1, &val2);
18428 if (!SWIG_IsOK(ecode2)) {
18429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18430 }
18431 arg2 = static_cast< int >(val2);
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 (arg1)->SetId(arg2);
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 resultobj = SWIG_Py_Void();
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18446 PyObject *resultobj = 0;
18447 wxEvent *arg1 = (wxEvent *) 0 ;
18448 bool result;
18449 void *argp1 = 0 ;
18450 int res1 = 0 ;
18451 PyObject *swig_obj[1] ;
18452
18453 if (!args) SWIG_fail;
18454 swig_obj[0] = args;
18455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18456 if (!SWIG_IsOK(res1)) {
18457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18458 }
18459 arg1 = reinterpret_cast< wxEvent * >(argp1);
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18463 wxPyEndAllowThreads(__tstate);
18464 if (PyErr_Occurred()) SWIG_fail;
18465 }
18466 {
18467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18468 }
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18476 PyObject *resultobj = 0;
18477 wxEvent *arg1 = (wxEvent *) 0 ;
18478 bool arg2 = (bool) true ;
18479 void *argp1 = 0 ;
18480 int res1 = 0 ;
18481 bool val2 ;
18482 int ecode2 = 0 ;
18483 PyObject * obj0 = 0 ;
18484 PyObject * obj1 = 0 ;
18485 char * kwnames[] = {
18486 (char *) "self",(char *) "skip", NULL
18487 };
18488
18489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18491 if (!SWIG_IsOK(res1)) {
18492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18493 }
18494 arg1 = reinterpret_cast< wxEvent * >(argp1);
18495 if (obj1) {
18496 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18497 if (!SWIG_IsOK(ecode2)) {
18498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18499 }
18500 arg2 = static_cast< bool >(val2);
18501 }
18502 {
18503 PyThreadState* __tstate = wxPyBeginAllowThreads();
18504 (arg1)->Skip(arg2);
18505 wxPyEndAllowThreads(__tstate);
18506 if (PyErr_Occurred()) SWIG_fail;
18507 }
18508 resultobj = SWIG_Py_Void();
18509 return resultobj;
18510 fail:
18511 return NULL;
18512 }
18513
18514
18515 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18516 PyObject *resultobj = 0;
18517 wxEvent *arg1 = (wxEvent *) 0 ;
18518 bool result;
18519 void *argp1 = 0 ;
18520 int res1 = 0 ;
18521 PyObject *swig_obj[1] ;
18522
18523 if (!args) SWIG_fail;
18524 swig_obj[0] = args;
18525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18526 if (!SWIG_IsOK(res1)) {
18527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18528 }
18529 arg1 = reinterpret_cast< wxEvent * >(argp1);
18530 {
18531 PyThreadState* __tstate = wxPyBeginAllowThreads();
18532 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18533 wxPyEndAllowThreads(__tstate);
18534 if (PyErr_Occurred()) SWIG_fail;
18535 }
18536 {
18537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18538 }
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18546 PyObject *resultobj = 0;
18547 wxEvent *arg1 = (wxEvent *) 0 ;
18548 bool result;
18549 void *argp1 = 0 ;
18550 int res1 = 0 ;
18551 PyObject *swig_obj[1] ;
18552
18553 if (!args) SWIG_fail;
18554 swig_obj[0] = args;
18555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18558 }
18559 arg1 = reinterpret_cast< wxEvent * >(argp1);
18560 {
18561 PyThreadState* __tstate = wxPyBeginAllowThreads();
18562 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18563 wxPyEndAllowThreads(__tstate);
18564 if (PyErr_Occurred()) SWIG_fail;
18565 }
18566 {
18567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18568 }
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18576 PyObject *resultobj = 0;
18577 wxEvent *arg1 = (wxEvent *) 0 ;
18578 int result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 PyObject *swig_obj[1] ;
18582
18583 if (!args) SWIG_fail;
18584 swig_obj[0] = args;
18585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18586 if (!SWIG_IsOK(res1)) {
18587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18588 }
18589 arg1 = reinterpret_cast< wxEvent * >(argp1);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (int)(arg1)->StopPropagation();
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_From_int(static_cast< int >(result));
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj = 0;
18605 wxEvent *arg1 = (wxEvent *) 0 ;
18606 int arg2 ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 int val2 ;
18610 int ecode2 = 0 ;
18611 PyObject * obj0 = 0 ;
18612 PyObject * obj1 = 0 ;
18613 char * kwnames[] = {
18614 (char *) "self",(char *) "propagationLevel", NULL
18615 };
18616
18617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18619 if (!SWIG_IsOK(res1)) {
18620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18621 }
18622 arg1 = reinterpret_cast< wxEvent * >(argp1);
18623 ecode2 = SWIG_AsVal_int(obj1, &val2);
18624 if (!SWIG_IsOK(ecode2)) {
18625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18626 }
18627 arg2 = static_cast< int >(val2);
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 (arg1)->ResumePropagation(arg2);
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 resultobj = SWIG_Py_Void();
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642 PyObject *resultobj = 0;
18643 wxEvent *arg1 = (wxEvent *) 0 ;
18644 wxEvent *result = 0 ;
18645 void *argp1 = 0 ;
18646 int res1 = 0 ;
18647 PyObject *swig_obj[1] ;
18648
18649 if (!args) SWIG_fail;
18650 swig_obj[0] = args;
18651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18652 if (!SWIG_IsOK(res1)) {
18653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18654 }
18655 arg1 = reinterpret_cast< wxEvent * >(argp1);
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (wxEvent *)(arg1)->Clone();
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *Event_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_wxEvent, SWIG_NewClientData(obj));
18673 return SWIG_Py_Void();
18674 }
18675
18676 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18677 PyObject *resultobj = 0;
18678 wxEvent *arg1 = 0 ;
18679 wxPropagationDisabler *result = 0 ;
18680 void *argp1 = 0 ;
18681 int res1 = 0 ;
18682 PyObject * obj0 = 0 ;
18683 char * kwnames[] = {
18684 (char *) "event", NULL
18685 };
18686
18687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18688 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18689 if (!SWIG_IsOK(res1)) {
18690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18691 }
18692 if (!argp1) {
18693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18694 }
18695 arg1 = reinterpret_cast< wxEvent * >(argp1);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18699 wxPyEndAllowThreads(__tstate);
18700 if (PyErr_Occurred()) SWIG_fail;
18701 }
18702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18721 }
18722 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 delete arg1;
18726
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_Py_Void();
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738 PyObject *obj;
18739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18740 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18741 return SWIG_Py_Void();
18742 }
18743
18744 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18745 return SWIG_Python_InitShadowInstance(args);
18746 }
18747
18748 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj = 0;
18750 wxEvent *arg1 = 0 ;
18751 wxPropagateOnce *result = 0 ;
18752 void *argp1 = 0 ;
18753 int res1 = 0 ;
18754 PyObject * obj0 = 0 ;
18755 char * kwnames[] = {
18756 (char *) "event", NULL
18757 };
18758
18759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18760 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18761 if (!SWIG_IsOK(res1)) {
18762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18763 }
18764 if (!argp1) {
18765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18766 }
18767 arg1 = reinterpret_cast< wxEvent * >(argp1);
18768 {
18769 PyThreadState* __tstate = wxPyBeginAllowThreads();
18770 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18771 wxPyEndAllowThreads(__tstate);
18772 if (PyErr_Occurred()) SWIG_fail;
18773 }
18774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18782 PyObject *resultobj = 0;
18783 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18784 void *argp1 = 0 ;
18785 int res1 = 0 ;
18786 PyObject *swig_obj[1] ;
18787
18788 if (!args) SWIG_fail;
18789 swig_obj[0] = args;
18790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18791 if (!SWIG_IsOK(res1)) {
18792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18793 }
18794 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 delete arg1;
18798
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 resultobj = SWIG_Py_Void();
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18810 PyObject *obj;
18811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18812 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18813 return SWIG_Py_Void();
18814 }
18815
18816 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18817 return SWIG_Python_InitShadowInstance(args);
18818 }
18819
18820 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18821 PyObject *resultobj = 0;
18822 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18823 int arg2 = (int) 0 ;
18824 wxCommandEvent *result = 0 ;
18825 int val1 ;
18826 int ecode1 = 0 ;
18827 int val2 ;
18828 int ecode2 = 0 ;
18829 PyObject * obj0 = 0 ;
18830 PyObject * obj1 = 0 ;
18831 char * kwnames[] = {
18832 (char *) "commandType",(char *) "winid", NULL
18833 };
18834
18835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18836 if (obj0) {
18837 ecode1 = SWIG_AsVal_int(obj0, &val1);
18838 if (!SWIG_IsOK(ecode1)) {
18839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18840 }
18841 arg1 = static_cast< wxEventType >(val1);
18842 }
18843 if (obj1) {
18844 ecode2 = SWIG_AsVal_int(obj1, &val2);
18845 if (!SWIG_IsOK(ecode2)) {
18846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18847 }
18848 arg2 = static_cast< int >(val2);
18849 }
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18864 PyObject *resultobj = 0;
18865 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18866 int result;
18867 void *argp1 = 0 ;
18868 int res1 = 0 ;
18869 PyObject *swig_obj[1] ;
18870
18871 if (!args) SWIG_fail;
18872 swig_obj[0] = args;
18873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18876 }
18877 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 resultobj = SWIG_From_int(static_cast< int >(result));
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18892 PyObject *resultobj = 0;
18893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18894 wxString *arg2 = 0 ;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 bool temp2 = false ;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char * kwnames[] = {
18901 (char *) "self",(char *) "s", NULL
18902 };
18903
18904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",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_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18908 }
18909 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18910 {
18911 arg2 = wxString_in_helper(obj1);
18912 if (arg2 == NULL) SWIG_fail;
18913 temp2 = true;
18914 }
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 (arg1)->SetString((wxString const &)*arg2);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_Py_Void();
18922 {
18923 if (temp2)
18924 delete arg2;
18925 }
18926 return resultobj;
18927 fail:
18928 {
18929 if (temp2)
18930 delete arg2;
18931 }
18932 return NULL;
18933 }
18934
18935
18936 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18937 PyObject *resultobj = 0;
18938 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18939 wxString result;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 PyObject *swig_obj[1] ;
18943
18944 if (!args) SWIG_fail;
18945 swig_obj[0] = args;
18946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18947 if (!SWIG_IsOK(res1)) {
18948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18949 }
18950 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = ((wxCommandEvent const *)arg1)->GetString();
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 {
18958 #if wxUSE_UNICODE
18959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18960 #else
18961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18962 #endif
18963 }
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18971 PyObject *resultobj = 0;
18972 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18973 bool result;
18974 void *argp1 = 0 ;
18975 int res1 = 0 ;
18976 PyObject *swig_obj[1] ;
18977
18978 if (!args) SWIG_fail;
18979 swig_obj[0] = args;
18980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18981 if (!SWIG_IsOK(res1)) {
18982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18983 }
18984 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18985 {
18986 PyThreadState* __tstate = wxPyBeginAllowThreads();
18987 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 {
18992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18993 }
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19001 PyObject *resultobj = 0;
19002 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19003 bool result;
19004 void *argp1 = 0 ;
19005 int res1 = 0 ;
19006 PyObject *swig_obj[1] ;
19007
19008 if (!args) SWIG_fail;
19009 swig_obj[0] = args;
19010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19011 if (!SWIG_IsOK(res1)) {
19012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19013 }
19014 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 {
19022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19023 }
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj = 0;
19032 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19033 long arg2 ;
19034 void *argp1 = 0 ;
19035 int res1 = 0 ;
19036 long val2 ;
19037 int ecode2 = 0 ;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 char * kwnames[] = {
19041 (char *) "self",(char *) "extraLong", NULL
19042 };
19043
19044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19046 if (!SWIG_IsOK(res1)) {
19047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19048 }
19049 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19050 ecode2 = SWIG_AsVal_long(obj1, &val2);
19051 if (!SWIG_IsOK(ecode2)) {
19052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19053 }
19054 arg2 = static_cast< long >(val2);
19055 {
19056 PyThreadState* __tstate = wxPyBeginAllowThreads();
19057 (arg1)->SetExtraLong(arg2);
19058 wxPyEndAllowThreads(__tstate);
19059 if (PyErr_Occurred()) SWIG_fail;
19060 }
19061 resultobj = SWIG_Py_Void();
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19069 PyObject *resultobj = 0;
19070 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19071 long result;
19072 void *argp1 = 0 ;
19073 int res1 = 0 ;
19074 PyObject *swig_obj[1] ;
19075
19076 if (!args) SWIG_fail;
19077 swig_obj[0] = args;
19078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19081 }
19082 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 resultobj = SWIG_From_long(static_cast< long >(result));
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj = 0;
19098 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19099 int arg2 ;
19100 void *argp1 = 0 ;
19101 int res1 = 0 ;
19102 int val2 ;
19103 int ecode2 = 0 ;
19104 PyObject * obj0 = 0 ;
19105 PyObject * obj1 = 0 ;
19106 char * kwnames[] = {
19107 (char *) "self",(char *) "i", NULL
19108 };
19109
19110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19114 }
19115 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19116 ecode2 = SWIG_AsVal_int(obj1, &val2);
19117 if (!SWIG_IsOK(ecode2)) {
19118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19119 }
19120 arg2 = static_cast< int >(val2);
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 (arg1)->SetInt(arg2);
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 resultobj = SWIG_Py_Void();
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19137 int result;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19147 }
19148 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_From_int(static_cast< int >(result));
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19163 PyObject *resultobj = 0;
19164 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19165 PyObject *result = 0 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 PyObject *swig_obj[1] ;
19169
19170 if (!args) SWIG_fail;
19171 swig_obj[0] = args;
19172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19173 if (!SWIG_IsOK(res1)) {
19174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19175 }
19176 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19180 wxPyEndAllowThreads(__tstate);
19181 if (PyErr_Occurred()) SWIG_fail;
19182 }
19183 resultobj = result;
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj = 0;
19192 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19193 PyObject *arg2 = (PyObject *) 0 ;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 PyObject * obj0 = 0 ;
19197 PyObject * obj1 = 0 ;
19198 char * kwnames[] = {
19199 (char *) "self",(char *) "clientData", NULL
19200 };
19201
19202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19204 if (!SWIG_IsOK(res1)) {
19205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19206 }
19207 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19208 arg2 = obj1;
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 wxCommandEvent_SetClientData(arg1,arg2);
19212 wxPyEndAllowThreads(__tstate);
19213 if (PyErr_Occurred()) SWIG_fail;
19214 }
19215 resultobj = SWIG_Py_Void();
19216 return resultobj;
19217 fail:
19218 return NULL;
19219 }
19220
19221
19222 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19223 PyObject *resultobj = 0;
19224 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19225 wxEvent *result = 0 ;
19226 void *argp1 = 0 ;
19227 int res1 = 0 ;
19228 PyObject *swig_obj[1] ;
19229
19230 if (!args) SWIG_fail;
19231 swig_obj[0] = args;
19232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19233 if (!SWIG_IsOK(res1)) {
19234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19235 }
19236 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *obj;
19252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19253 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19254 return SWIG_Py_Void();
19255 }
19256
19257 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 return SWIG_Python_InitShadowInstance(args);
19259 }
19260
19261 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj = 0;
19263 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19264 int arg2 = (int) 0 ;
19265 wxNotifyEvent *result = 0 ;
19266 int val1 ;
19267 int ecode1 = 0 ;
19268 int val2 ;
19269 int ecode2 = 0 ;
19270 PyObject * obj0 = 0 ;
19271 PyObject * obj1 = 0 ;
19272 char * kwnames[] = {
19273 (char *) "commandType",(char *) "winid", NULL
19274 };
19275
19276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19277 if (obj0) {
19278 ecode1 = SWIG_AsVal_int(obj0, &val1);
19279 if (!SWIG_IsOK(ecode1)) {
19280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19281 }
19282 arg1 = static_cast< wxEventType >(val1);
19283 }
19284 if (obj1) {
19285 ecode2 = SWIG_AsVal_int(obj1, &val2);
19286 if (!SWIG_IsOK(ecode2)) {
19287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19288 }
19289 arg2 = static_cast< int >(val2);
19290 }
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19305 PyObject *resultobj = 0;
19306 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19307 void *argp1 = 0 ;
19308 int res1 = 0 ;
19309 PyObject *swig_obj[1] ;
19310
19311 if (!args) SWIG_fail;
19312 swig_obj[0] = args;
19313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19314 if (!SWIG_IsOK(res1)) {
19315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19316 }
19317 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19318 {
19319 PyThreadState* __tstate = wxPyBeginAllowThreads();
19320 (arg1)->Veto();
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 resultobj = SWIG_Py_Void();
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19332 PyObject *resultobj = 0;
19333 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19334 void *argp1 = 0 ;
19335 int res1 = 0 ;
19336 PyObject *swig_obj[1] ;
19337
19338 if (!args) SWIG_fail;
19339 swig_obj[0] = args;
19340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19341 if (!SWIG_IsOK(res1)) {
19342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19343 }
19344 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 (arg1)->Allow();
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 resultobj = SWIG_Py_Void();
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19359 PyObject *resultobj = 0;
19360 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19361 bool result;
19362 void *argp1 = 0 ;
19363 int res1 = 0 ;
19364 PyObject *swig_obj[1] ;
19365
19366 if (!args) SWIG_fail;
19367 swig_obj[0] = args;
19368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19369 if (!SWIG_IsOK(res1)) {
19370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19371 }
19372 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (bool)(arg1)->IsAllowed();
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 {
19380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19389 PyObject *obj;
19390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19391 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19392 return SWIG_Py_Void();
19393 }
19394
19395 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19396 return SWIG_Python_InitShadowInstance(args);
19397 }
19398
19399 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj = 0;
19401 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19402 int arg2 = (int) 0 ;
19403 int arg3 = (int) 0 ;
19404 int arg4 = (int) 0 ;
19405 wxScrollEvent *result = 0 ;
19406 int val1 ;
19407 int ecode1 = 0 ;
19408 int val2 ;
19409 int ecode2 = 0 ;
19410 int val3 ;
19411 int ecode3 = 0 ;
19412 int val4 ;
19413 int ecode4 = 0 ;
19414 PyObject * obj0 = 0 ;
19415 PyObject * obj1 = 0 ;
19416 PyObject * obj2 = 0 ;
19417 PyObject * obj3 = 0 ;
19418 char * kwnames[] = {
19419 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19420 };
19421
19422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19423 if (obj0) {
19424 ecode1 = SWIG_AsVal_int(obj0, &val1);
19425 if (!SWIG_IsOK(ecode1)) {
19426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19427 }
19428 arg1 = static_cast< wxEventType >(val1);
19429 }
19430 if (obj1) {
19431 ecode2 = SWIG_AsVal_int(obj1, &val2);
19432 if (!SWIG_IsOK(ecode2)) {
19433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19434 }
19435 arg2 = static_cast< int >(val2);
19436 }
19437 if (obj2) {
19438 ecode3 = SWIG_AsVal_int(obj2, &val3);
19439 if (!SWIG_IsOK(ecode3)) {
19440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19441 }
19442 arg3 = static_cast< int >(val3);
19443 }
19444 if (obj3) {
19445 ecode4 = SWIG_AsVal_int(obj3, &val4);
19446 if (!SWIG_IsOK(ecode4)) {
19447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19448 }
19449 arg4 = static_cast< int >(val4);
19450 }
19451 {
19452 PyThreadState* __tstate = wxPyBeginAllowThreads();
19453 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19454 wxPyEndAllowThreads(__tstate);
19455 if (PyErr_Occurred()) SWIG_fail;
19456 }
19457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19465 PyObject *resultobj = 0;
19466 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19467 int result;
19468 void *argp1 = 0 ;
19469 int res1 = 0 ;
19470 PyObject *swig_obj[1] ;
19471
19472 if (!args) SWIG_fail;
19473 swig_obj[0] = args;
19474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19475 if (!SWIG_IsOK(res1)) {
19476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19477 }
19478 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_From_int(static_cast< int >(result));
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 PyObject *resultobj = 0;
19494 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19495 int result;
19496 void *argp1 = 0 ;
19497 int res1 = 0 ;
19498 PyObject *swig_obj[1] ;
19499
19500 if (!args) SWIG_fail;
19501 swig_obj[0] = args;
19502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19503 if (!SWIG_IsOK(res1)) {
19504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19505 }
19506 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_From_int(static_cast< int >(result));
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj = 0;
19522 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19523 int arg2 ;
19524 void *argp1 = 0 ;
19525 int res1 = 0 ;
19526 int val2 ;
19527 int ecode2 = 0 ;
19528 PyObject * obj0 = 0 ;
19529 PyObject * obj1 = 0 ;
19530 char * kwnames[] = {
19531 (char *) "self",(char *) "orient", NULL
19532 };
19533
19534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19536 if (!SWIG_IsOK(res1)) {
19537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19538 }
19539 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19540 ecode2 = SWIG_AsVal_int(obj1, &val2);
19541 if (!SWIG_IsOK(ecode2)) {
19542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19543 }
19544 arg2 = static_cast< int >(val2);
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 (arg1)->SetOrientation(arg2);
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 resultobj = SWIG_Py_Void();
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj = 0;
19560 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19561 int arg2 ;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 int val2 ;
19565 int ecode2 = 0 ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 char * kwnames[] = {
19569 (char *) "self",(char *) "pos", NULL
19570 };
19571
19572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19574 if (!SWIG_IsOK(res1)) {
19575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19576 }
19577 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19578 ecode2 = SWIG_AsVal_int(obj1, &val2);
19579 if (!SWIG_IsOK(ecode2)) {
19580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19581 }
19582 arg2 = static_cast< int >(val2);
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 (arg1)->SetPosition(arg2);
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 resultobj = SWIG_Py_Void();
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19597 PyObject *obj;
19598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19599 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19600 return SWIG_Py_Void();
19601 }
19602
19603 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19604 return SWIG_Python_InitShadowInstance(args);
19605 }
19606
19607 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj = 0;
19609 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19610 int arg2 = (int) 0 ;
19611 int arg3 = (int) 0 ;
19612 wxScrollWinEvent *result = 0 ;
19613 int val1 ;
19614 int ecode1 = 0 ;
19615 int val2 ;
19616 int ecode2 = 0 ;
19617 int val3 ;
19618 int ecode3 = 0 ;
19619 PyObject * obj0 = 0 ;
19620 PyObject * obj1 = 0 ;
19621 PyObject * obj2 = 0 ;
19622 char * kwnames[] = {
19623 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19624 };
19625
19626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19627 if (obj0) {
19628 ecode1 = SWIG_AsVal_int(obj0, &val1);
19629 if (!SWIG_IsOK(ecode1)) {
19630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19631 }
19632 arg1 = static_cast< wxEventType >(val1);
19633 }
19634 if (obj1) {
19635 ecode2 = SWIG_AsVal_int(obj1, &val2);
19636 if (!SWIG_IsOK(ecode2)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19638 }
19639 arg2 = static_cast< int >(val2);
19640 }
19641 if (obj2) {
19642 ecode3 = SWIG_AsVal_int(obj2, &val3);
19643 if (!SWIG_IsOK(ecode3)) {
19644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19645 }
19646 arg3 = static_cast< int >(val3);
19647 }
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19651 wxPyEndAllowThreads(__tstate);
19652 if (PyErr_Occurred()) SWIG_fail;
19653 }
19654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19655 return resultobj;
19656 fail:
19657 return NULL;
19658 }
19659
19660
19661 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19662 PyObject *resultobj = 0;
19663 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19664 int result;
19665 void *argp1 = 0 ;
19666 int res1 = 0 ;
19667 PyObject *swig_obj[1] ;
19668
19669 if (!args) SWIG_fail;
19670 swig_obj[0] = args;
19671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19672 if (!SWIG_IsOK(res1)) {
19673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19674 }
19675 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_From_int(static_cast< int >(result));
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19690 PyObject *resultobj = 0;
19691 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19692 int result;
19693 void *argp1 = 0 ;
19694 int res1 = 0 ;
19695 PyObject *swig_obj[1] ;
19696
19697 if (!args) SWIG_fail;
19698 swig_obj[0] = args;
19699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19700 if (!SWIG_IsOK(res1)) {
19701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19702 }
19703 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19704 {
19705 PyThreadState* __tstate = wxPyBeginAllowThreads();
19706 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19707 wxPyEndAllowThreads(__tstate);
19708 if (PyErr_Occurred()) SWIG_fail;
19709 }
19710 resultobj = SWIG_From_int(static_cast< int >(result));
19711 return resultobj;
19712 fail:
19713 return NULL;
19714 }
19715
19716
19717 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19718 PyObject *resultobj = 0;
19719 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19720 int arg2 ;
19721 void *argp1 = 0 ;
19722 int res1 = 0 ;
19723 int val2 ;
19724 int ecode2 = 0 ;
19725 PyObject * obj0 = 0 ;
19726 PyObject * obj1 = 0 ;
19727 char * kwnames[] = {
19728 (char *) "self",(char *) "orient", NULL
19729 };
19730
19731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19733 if (!SWIG_IsOK(res1)) {
19734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19735 }
19736 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19737 ecode2 = SWIG_AsVal_int(obj1, &val2);
19738 if (!SWIG_IsOK(ecode2)) {
19739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19740 }
19741 arg2 = static_cast< int >(val2);
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 (arg1)->SetOrientation(arg2);
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_Py_Void();
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj = 0;
19757 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19758 int arg2 ;
19759 void *argp1 = 0 ;
19760 int res1 = 0 ;
19761 int val2 ;
19762 int ecode2 = 0 ;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char * kwnames[] = {
19766 (char *) "self",(char *) "pos", NULL
19767 };
19768
19769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19771 if (!SWIG_IsOK(res1)) {
19772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19773 }
19774 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19775 ecode2 = SWIG_AsVal_int(obj1, &val2);
19776 if (!SWIG_IsOK(ecode2)) {
19777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19778 }
19779 arg2 = static_cast< int >(val2);
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 (arg1)->SetPosition(arg2);
19783 wxPyEndAllowThreads(__tstate);
19784 if (PyErr_Occurred()) SWIG_fail;
19785 }
19786 resultobj = SWIG_Py_Void();
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19794 PyObject *obj;
19795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19796 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19797 return SWIG_Py_Void();
19798 }
19799
19800 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19801 return SWIG_Python_InitShadowInstance(args);
19802 }
19803
19804 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19805 PyObject *resultobj = 0;
19806 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19807 wxMouseEvent *result = 0 ;
19808 int val1 ;
19809 int ecode1 = 0 ;
19810 PyObject * obj0 = 0 ;
19811 char * kwnames[] = {
19812 (char *) "mouseType", NULL
19813 };
19814
19815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19816 if (obj0) {
19817 ecode1 = SWIG_AsVal_int(obj0, &val1);
19818 if (!SWIG_IsOK(ecode1)) {
19819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19820 }
19821 arg1 = static_cast< wxEventType >(val1);
19822 }
19823 {
19824 PyThreadState* __tstate = wxPyBeginAllowThreads();
19825 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19826 wxPyEndAllowThreads(__tstate);
19827 if (PyErr_Occurred()) SWIG_fail;
19828 }
19829 {
19830 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19831 }
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19839 PyObject *resultobj = 0;
19840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19841 bool result;
19842 void *argp1 = 0 ;
19843 int res1 = 0 ;
19844 PyObject *swig_obj[1] ;
19845
19846 if (!args) SWIG_fail;
19847 swig_obj[0] = args;
19848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19849 if (!SWIG_IsOK(res1)) {
19850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19851 }
19852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19853 {
19854 PyThreadState* __tstate = wxPyBeginAllowThreads();
19855 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19856 wxPyEndAllowThreads(__tstate);
19857 if (PyErr_Occurred()) SWIG_fail;
19858 }
19859 {
19860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19861 }
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19869 PyObject *resultobj = 0;
19870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19871 int arg2 = (int) wxMOUSE_BTN_ANY ;
19872 bool result;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 int val2 ;
19876 int ecode2 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 PyObject * obj1 = 0 ;
19879 char * kwnames[] = {
19880 (char *) "self",(char *) "but", NULL
19881 };
19882
19883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19885 if (!SWIG_IsOK(res1)) {
19886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19887 }
19888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19889 if (obj1) {
19890 ecode2 = SWIG_AsVal_int(obj1, &val2);
19891 if (!SWIG_IsOK(ecode2)) {
19892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19893 }
19894 arg2 = static_cast< int >(val2);
19895 }
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19899 wxPyEndAllowThreads(__tstate);
19900 if (PyErr_Occurred()) SWIG_fail;
19901 }
19902 {
19903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19904 }
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19912 PyObject *resultobj = 0;
19913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19914 int arg2 = (int) wxMOUSE_BTN_ANY ;
19915 bool result;
19916 void *argp1 = 0 ;
19917 int res1 = 0 ;
19918 int val2 ;
19919 int ecode2 = 0 ;
19920 PyObject * obj0 = 0 ;
19921 PyObject * obj1 = 0 ;
19922 char * kwnames[] = {
19923 (char *) "self",(char *) "but", NULL
19924 };
19925
19926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19928 if (!SWIG_IsOK(res1)) {
19929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19930 }
19931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19932 if (obj1) {
19933 ecode2 = SWIG_AsVal_int(obj1, &val2);
19934 if (!SWIG_IsOK(ecode2)) {
19935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19936 }
19937 arg2 = static_cast< int >(val2);
19938 }
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 {
19946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19947 }
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19955 PyObject *resultobj = 0;
19956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19957 int arg2 = (int) wxMOUSE_BTN_ANY ;
19958 bool result;
19959 void *argp1 = 0 ;
19960 int res1 = 0 ;
19961 int val2 ;
19962 int ecode2 = 0 ;
19963 PyObject * obj0 = 0 ;
19964 PyObject * obj1 = 0 ;
19965 char * kwnames[] = {
19966 (char *) "self",(char *) "but", NULL
19967 };
19968
19969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19971 if (!SWIG_IsOK(res1)) {
19972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19973 }
19974 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19975 if (obj1) {
19976 ecode2 = SWIG_AsVal_int(obj1, &val2);
19977 if (!SWIG_IsOK(ecode2)) {
19978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19979 }
19980 arg2 = static_cast< int >(val2);
19981 }
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
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_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj = 0;
19999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20000 int arg2 ;
20001 bool result;
20002 void *argp1 = 0 ;
20003 int res1 = 0 ;
20004 int val2 ;
20005 int ecode2 = 0 ;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 char * kwnames[] = {
20009 (char *) "self",(char *) "button", NULL
20010 };
20011
20012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20014 if (!SWIG_IsOK(res1)) {
20015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20016 }
20017 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20018 ecode2 = SWIG_AsVal_int(obj1, &val2);
20019 if (!SWIG_IsOK(ecode2)) {
20020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20021 }
20022 arg2 = static_cast< int >(val2);
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 {
20030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20031 }
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20039 PyObject *resultobj = 0;
20040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20041 int arg2 ;
20042 bool result;
20043 void *argp1 = 0 ;
20044 int res1 = 0 ;
20045 int val2 ;
20046 int ecode2 = 0 ;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char * kwnames[] = {
20050 (char *) "self",(char *) "but", NULL
20051 };
20052
20053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20057 }
20058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20059 ecode2 = SWIG_AsVal_int(obj1, &val2);
20060 if (!SWIG_IsOK(ecode2)) {
20061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20062 }
20063 arg2 = static_cast< int >(val2);
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 {
20071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20072 }
20073 return resultobj;
20074 fail:
20075 return NULL;
20076 }
20077
20078
20079 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20080 PyObject *resultobj = 0;
20081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20082 int result;
20083 void *argp1 = 0 ;
20084 int res1 = 0 ;
20085 PyObject *swig_obj[1] ;
20086
20087 if (!args) SWIG_fail;
20088 swig_obj[0] = args;
20089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20090 if (!SWIG_IsOK(res1)) {
20091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20092 }
20093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 resultobj = SWIG_From_int(static_cast< int >(result));
20101 return resultobj;
20102 fail:
20103 return NULL;
20104 }
20105
20106
20107 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108 PyObject *resultobj = 0;
20109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20110 bool result;
20111 void *argp1 = 0 ;
20112 int res1 = 0 ;
20113 PyObject *swig_obj[1] ;
20114
20115 if (!args) SWIG_fail;
20116 swig_obj[0] = args;
20117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20118 if (!SWIG_IsOK(res1)) {
20119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20120 }
20121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 {
20129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20138 PyObject *resultobj = 0;
20139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20140 bool result;
20141 void *argp1 = 0 ;
20142 int res1 = 0 ;
20143 PyObject *swig_obj[1] ;
20144
20145 if (!args) SWIG_fail;
20146 swig_obj[0] = args;
20147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20148 if (!SWIG_IsOK(res1)) {
20149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20150 }
20151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 {
20159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20160 }
20161 return resultobj;
20162 fail:
20163 return NULL;
20164 }
20165
20166
20167 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 PyObject *resultobj = 0;
20169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20170 bool result;
20171 void *argp1 = 0 ;
20172 int res1 = 0 ;
20173 PyObject *swig_obj[1] ;
20174
20175 if (!args) SWIG_fail;
20176 swig_obj[0] = args;
20177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20178 if (!SWIG_IsOK(res1)) {
20179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20180 }
20181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20182 {
20183 PyThreadState* __tstate = wxPyBeginAllowThreads();
20184 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20185 wxPyEndAllowThreads(__tstate);
20186 if (PyErr_Occurred()) SWIG_fail;
20187 }
20188 {
20189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20190 }
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20198 PyObject *resultobj = 0;
20199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20200 bool result;
20201 void *argp1 = 0 ;
20202 int res1 = 0 ;
20203 PyObject *swig_obj[1] ;
20204
20205 if (!args) SWIG_fail;
20206 swig_obj[0] = args;
20207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20208 if (!SWIG_IsOK(res1)) {
20209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20210 }
20211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20212 {
20213 PyThreadState* __tstate = wxPyBeginAllowThreads();
20214 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 {
20219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20220 }
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20228 PyObject *resultobj = 0;
20229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20230 bool result;
20231 void *argp1 = 0 ;
20232 int res1 = 0 ;
20233 PyObject *swig_obj[1] ;
20234
20235 if (!args) SWIG_fail;
20236 swig_obj[0] = args;
20237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20238 if (!SWIG_IsOK(res1)) {
20239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20240 }
20241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20242 {
20243 PyThreadState* __tstate = wxPyBeginAllowThreads();
20244 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 {
20249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20250 }
20251 return resultobj;
20252 fail:
20253 return NULL;
20254 }
20255
20256
20257 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *resultobj = 0;
20259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20260 bool result;
20261 void *argp1 = 0 ;
20262 int res1 = 0 ;
20263 PyObject *swig_obj[1] ;
20264
20265 if (!args) SWIG_fail;
20266 swig_obj[0] = args;
20267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20268 if (!SWIG_IsOK(res1)) {
20269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20270 }
20271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 {
20279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20280 }
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20290 bool result;
20291 void *argp1 = 0 ;
20292 int res1 = 0 ;
20293 PyObject *swig_obj[1] ;
20294
20295 if (!args) SWIG_fail;
20296 swig_obj[0] = args;
20297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20298 if (!SWIG_IsOK(res1)) {
20299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20300 }
20301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20302 {
20303 PyThreadState* __tstate = wxPyBeginAllowThreads();
20304 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 {
20309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20310 }
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20318 PyObject *resultobj = 0;
20319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20320 bool result;
20321 void *argp1 = 0 ;
20322 int res1 = 0 ;
20323 PyObject *swig_obj[1] ;
20324
20325 if (!args) SWIG_fail;
20326 swig_obj[0] = args;
20327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20328 if (!SWIG_IsOK(res1)) {
20329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20330 }
20331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 {
20339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20340 }
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20348 PyObject *resultobj = 0;
20349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20350 bool result;
20351 void *argp1 = 0 ;
20352 int res1 = 0 ;
20353 PyObject *swig_obj[1] ;
20354
20355 if (!args) SWIG_fail;
20356 swig_obj[0] = args;
20357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20358 if (!SWIG_IsOK(res1)) {
20359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20360 }
20361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 {
20369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20370 }
20371 return resultobj;
20372 fail:
20373 return NULL;
20374 }
20375
20376
20377 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20378 PyObject *resultobj = 0;
20379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20380 bool result;
20381 void *argp1 = 0 ;
20382 int res1 = 0 ;
20383 PyObject *swig_obj[1] ;
20384
20385 if (!args) SWIG_fail;
20386 swig_obj[0] = args;
20387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20388 if (!SWIG_IsOK(res1)) {
20389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20390 }
20391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 {
20399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20400 }
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 PyObject *resultobj = 0;
20409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20410 bool result;
20411 void *argp1 = 0 ;
20412 int res1 = 0 ;
20413 PyObject *swig_obj[1] ;
20414
20415 if (!args) SWIG_fail;
20416 swig_obj[0] = args;
20417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20418 if (!SWIG_IsOK(res1)) {
20419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20420 }
20421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 {
20429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20430 }
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *resultobj = 0;
20439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20440 bool result;
20441 void *argp1 = 0 ;
20442 int res1 = 0 ;
20443 PyObject *swig_obj[1] ;
20444
20445 if (!args) SWIG_fail;
20446 swig_obj[0] = args;
20447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20448 if (!SWIG_IsOK(res1)) {
20449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20450 }
20451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 {
20459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20460 }
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20468 PyObject *resultobj = 0;
20469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20470 bool result;
20471 void *argp1 = 0 ;
20472 int res1 = 0 ;
20473 PyObject *swig_obj[1] ;
20474
20475 if (!args) SWIG_fail;
20476 swig_obj[0] = args;
20477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20478 if (!SWIG_IsOK(res1)) {
20479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20480 }
20481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 {
20489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20490 }
20491 return resultobj;
20492 fail:
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20498 PyObject *resultobj = 0;
20499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20500 bool result;
20501 void *argp1 = 0 ;
20502 int res1 = 0 ;
20503 PyObject *swig_obj[1] ;
20504
20505 if (!args) SWIG_fail;
20506 swig_obj[0] = args;
20507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20508 if (!SWIG_IsOK(res1)) {
20509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20510 }
20511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 {
20519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20520 }
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20528 PyObject *resultobj = 0;
20529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20530 bool result;
20531 void *argp1 = 0 ;
20532 int res1 = 0 ;
20533 PyObject *swig_obj[1] ;
20534
20535 if (!args) SWIG_fail;
20536 swig_obj[0] = args;
20537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20538 if (!SWIG_IsOK(res1)) {
20539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20540 }
20541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (bool)(arg1)->LeftIsDown();
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 {
20549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20550 }
20551 return resultobj;
20552 fail:
20553 return NULL;
20554 }
20555
20556
20557 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20558 PyObject *resultobj = 0;
20559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20560 bool result;
20561 void *argp1 = 0 ;
20562 int res1 = 0 ;
20563 PyObject *swig_obj[1] ;
20564
20565 if (!args) SWIG_fail;
20566 swig_obj[0] = args;
20567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20568 if (!SWIG_IsOK(res1)) {
20569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20570 }
20571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)(arg1)->MiddleIsDown();
20575 wxPyEndAllowThreads(__tstate);
20576 if (PyErr_Occurred()) SWIG_fail;
20577 }
20578 {
20579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20580 }
20581 return resultobj;
20582 fail:
20583 return NULL;
20584 }
20585
20586
20587 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20588 PyObject *resultobj = 0;
20589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20590 bool result;
20591 void *argp1 = 0 ;
20592 int res1 = 0 ;
20593 PyObject *swig_obj[1] ;
20594
20595 if (!args) SWIG_fail;
20596 swig_obj[0] = args;
20597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20598 if (!SWIG_IsOK(res1)) {
20599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20600 }
20601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)(arg1)->RightIsDown();
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 {
20609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20610 }
20611 return resultobj;
20612 fail:
20613 return NULL;
20614 }
20615
20616
20617 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 PyObject *resultobj = 0;
20619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20620 bool result;
20621 void *argp1 = 0 ;
20622 int res1 = 0 ;
20623 PyObject *swig_obj[1] ;
20624
20625 if (!args) SWIG_fail;
20626 swig_obj[0] = args;
20627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20628 if (!SWIG_IsOK(res1)) {
20629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20630 }
20631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 {
20639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20640 }
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20648 PyObject *resultobj = 0;
20649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20650 bool result;
20651 void *argp1 = 0 ;
20652 int res1 = 0 ;
20653 PyObject *swig_obj[1] ;
20654
20655 if (!args) SWIG_fail;
20656 swig_obj[0] = args;
20657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20658 if (!SWIG_IsOK(res1)) {
20659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20660 }
20661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20678 PyObject *resultobj = 0;
20679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20680 bool result;
20681 void *argp1 = 0 ;
20682 int res1 = 0 ;
20683 PyObject *swig_obj[1] ;
20684
20685 if (!args) SWIG_fail;
20686 swig_obj[0] = args;
20687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20688 if (!SWIG_IsOK(res1)) {
20689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20690 }
20691 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 {
20699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20700 }
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708 PyObject *resultobj = 0;
20709 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20710 bool result;
20711 void *argp1 = 0 ;
20712 int res1 = 0 ;
20713 PyObject *swig_obj[1] ;
20714
20715 if (!args) SWIG_fail;
20716 swig_obj[0] = args;
20717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20720 }
20721 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 {
20729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20738 PyObject *resultobj = 0;
20739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20740 wxPoint result;
20741 void *argp1 = 0 ;
20742 int res1 = 0 ;
20743 PyObject *swig_obj[1] ;
20744
20745 if (!args) SWIG_fail;
20746 swig_obj[0] = args;
20747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20748 if (!SWIG_IsOK(res1)) {
20749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20750 }
20751 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20752 {
20753 PyThreadState* __tstate = wxPyBeginAllowThreads();
20754 result = (arg1)->GetPosition();
20755 wxPyEndAllowThreads(__tstate);
20756 if (PyErr_Occurred()) SWIG_fail;
20757 }
20758 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20759 return resultobj;
20760 fail:
20761 return NULL;
20762 }
20763
20764
20765 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20766 PyObject *resultobj = 0;
20767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20768 long *arg2 = (long *) 0 ;
20769 long *arg3 = (long *) 0 ;
20770 void *argp1 = 0 ;
20771 int res1 = 0 ;
20772 long temp2 ;
20773 int res2 = SWIG_TMPOBJ ;
20774 long temp3 ;
20775 int res3 = SWIG_TMPOBJ ;
20776 PyObject *swig_obj[1] ;
20777
20778 arg2 = &temp2;
20779 arg3 = &temp3;
20780 if (!args) SWIG_fail;
20781 swig_obj[0] = args;
20782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20783 if (!SWIG_IsOK(res1)) {
20784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20785 }
20786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 (arg1)->GetPosition(arg2,arg3);
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 resultobj = SWIG_Py_Void();
20794 if (SWIG_IsTmpObj(res2)) {
20795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20796 } else {
20797 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20799 }
20800 if (SWIG_IsTmpObj(res3)) {
20801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20802 } else {
20803 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20805 }
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20813 PyObject *resultobj = 0;
20814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20815 wxDC *arg2 = 0 ;
20816 wxPoint result;
20817 void *argp1 = 0 ;
20818 int res1 = 0 ;
20819 void *argp2 = 0 ;
20820 int res2 = 0 ;
20821 PyObject * obj0 = 0 ;
20822 PyObject * obj1 = 0 ;
20823 char * kwnames[] = {
20824 (char *) "self",(char *) "dc", NULL
20825 };
20826
20827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20829 if (!SWIG_IsOK(res1)) {
20830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20831 }
20832 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20834 if (!SWIG_IsOK(res2)) {
20835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20836 }
20837 if (!argp2) {
20838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20839 }
20840 arg2 = reinterpret_cast< wxDC * >(argp2);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20857 int 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_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (int)((wxMouseEvent const *)arg1)->GetX();
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_From_int(static_cast< int >(result));
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20885 int result;
20886 void *argp1 = 0 ;
20887 int res1 = 0 ;
20888 PyObject *swig_obj[1] ;
20889
20890 if (!args) SWIG_fail;
20891 swig_obj[0] = args;
20892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20893 if (!SWIG_IsOK(res1)) {
20894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20895 }
20896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (int)((wxMouseEvent const *)arg1)->GetY();
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 resultobj = SWIG_From_int(static_cast< int >(result));
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20913 int result;
20914 void *argp1 = 0 ;
20915 int res1 = 0 ;
20916 PyObject *swig_obj[1] ;
20917
20918 if (!args) SWIG_fail;
20919 swig_obj[0] = args;
20920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20921 if (!SWIG_IsOK(res1)) {
20922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20923 }
20924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 resultobj = SWIG_From_int(static_cast< int >(result));
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20939 PyObject *resultobj = 0;
20940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20941 int result;
20942 void *argp1 = 0 ;
20943 int res1 = 0 ;
20944 PyObject *swig_obj[1] ;
20945
20946 if (!args) SWIG_fail;
20947 swig_obj[0] = args;
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_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20951 }
20952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20953 {
20954 PyThreadState* __tstate = wxPyBeginAllowThreads();
20955 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 resultobj = SWIG_From_int(static_cast< int >(result));
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20967 PyObject *resultobj = 0;
20968 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20969 int result;
20970 void *argp1 = 0 ;
20971 int res1 = 0 ;
20972 PyObject *swig_obj[1] ;
20973
20974 if (!args) SWIG_fail;
20975 swig_obj[0] = args;
20976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20977 if (!SWIG_IsOK(res1)) {
20978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20979 }
20980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 resultobj = SWIG_From_int(static_cast< int >(result));
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20995 PyObject *resultobj = 0;
20996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20997 bool result;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 PyObject *swig_obj[1] ;
21001
21002 if (!args) SWIG_fail;
21003 swig_obj[0] = args;
21004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21005 if (!SWIG_IsOK(res1)) {
21006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21007 }
21008 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 {
21016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21017 }
21018 return resultobj;
21019 fail:
21020 return NULL;
21021 }
21022
21023
21024 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21025 PyObject *resultobj = 0;
21026 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21027 int arg2 ;
21028 void *argp1 = 0 ;
21029 int res1 = 0 ;
21030 int val2 ;
21031 int ecode2 = 0 ;
21032 PyObject *swig_obj[2] ;
21033
21034 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21036 if (!SWIG_IsOK(res1)) {
21037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21038 }
21039 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21041 if (!SWIG_IsOK(ecode2)) {
21042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21043 }
21044 arg2 = static_cast< int >(val2);
21045 if (arg1) (arg1)->m_x = arg2;
21046
21047 resultobj = SWIG_Py_Void();
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21055 PyObject *resultobj = 0;
21056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21057 int result;
21058 void *argp1 = 0 ;
21059 int res1 = 0 ;
21060 PyObject *swig_obj[1] ;
21061
21062 if (!args) SWIG_fail;
21063 swig_obj[0] = args;
21064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21065 if (!SWIG_IsOK(res1)) {
21066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21067 }
21068 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21069 result = (int) ((arg1)->m_x);
21070 resultobj = SWIG_From_int(static_cast< int >(result));
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21080 int arg2 ;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 int val2 ;
21084 int ecode2 = 0 ;
21085 PyObject *swig_obj[2] ;
21086
21087 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21089 if (!SWIG_IsOK(res1)) {
21090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21091 }
21092 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21093 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21094 if (!SWIG_IsOK(ecode2)) {
21095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21096 }
21097 arg2 = static_cast< int >(val2);
21098 if (arg1) (arg1)->m_y = arg2;
21099
21100 resultobj = SWIG_Py_Void();
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21108 PyObject *resultobj = 0;
21109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21110 int result;
21111 void *argp1 = 0 ;
21112 int res1 = 0 ;
21113 PyObject *swig_obj[1] ;
21114
21115 if (!args) SWIG_fail;
21116 swig_obj[0] = args;
21117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21118 if (!SWIG_IsOK(res1)) {
21119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21120 }
21121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21122 result = (int) ((arg1)->m_y);
21123 resultobj = SWIG_From_int(static_cast< int >(result));
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21133 bool arg2 ;
21134 void *argp1 = 0 ;
21135 int res1 = 0 ;
21136 bool val2 ;
21137 int ecode2 = 0 ;
21138 PyObject *swig_obj[2] ;
21139
21140 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21144 }
21145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21146 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21147 if (!SWIG_IsOK(ecode2)) {
21148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21149 }
21150 arg2 = static_cast< bool >(val2);
21151 if (arg1) (arg1)->m_leftDown = arg2;
21152
21153 resultobj = SWIG_Py_Void();
21154 return resultobj;
21155 fail:
21156 return NULL;
21157 }
21158
21159
21160 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21161 PyObject *resultobj = 0;
21162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21163 bool result;
21164 void *argp1 = 0 ;
21165 int res1 = 0 ;
21166 PyObject *swig_obj[1] ;
21167
21168 if (!args) SWIG_fail;
21169 swig_obj[0] = args;
21170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21171 if (!SWIG_IsOK(res1)) {
21172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21173 }
21174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21175 result = (bool) ((arg1)->m_leftDown);
21176 {
21177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21178 }
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21186 PyObject *resultobj = 0;
21187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21188 bool arg2 ;
21189 void *argp1 = 0 ;
21190 int res1 = 0 ;
21191 bool val2 ;
21192 int ecode2 = 0 ;
21193 PyObject *swig_obj[2] ;
21194
21195 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21197 if (!SWIG_IsOK(res1)) {
21198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21199 }
21200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21201 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21202 if (!SWIG_IsOK(ecode2)) {
21203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21204 }
21205 arg2 = static_cast< bool >(val2);
21206 if (arg1) (arg1)->m_middleDown = arg2;
21207
21208 resultobj = SWIG_Py_Void();
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21216 PyObject *resultobj = 0;
21217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21218 bool result;
21219 void *argp1 = 0 ;
21220 int res1 = 0 ;
21221 PyObject *swig_obj[1] ;
21222
21223 if (!args) SWIG_fail;
21224 swig_obj[0] = args;
21225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21226 if (!SWIG_IsOK(res1)) {
21227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21228 }
21229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21230 result = (bool) ((arg1)->m_middleDown);
21231 {
21232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21233 }
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21241 PyObject *resultobj = 0;
21242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21243 bool arg2 ;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 bool val2 ;
21247 int ecode2 = 0 ;
21248 PyObject *swig_obj[2] ;
21249
21250 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21252 if (!SWIG_IsOK(res1)) {
21253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21254 }
21255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21256 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21257 if (!SWIG_IsOK(ecode2)) {
21258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21259 }
21260 arg2 = static_cast< bool >(val2);
21261 if (arg1) (arg1)->m_rightDown = arg2;
21262
21263 resultobj = SWIG_Py_Void();
21264 return resultobj;
21265 fail:
21266 return NULL;
21267 }
21268
21269
21270 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21271 PyObject *resultobj = 0;
21272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21273 bool result;
21274 void *argp1 = 0 ;
21275 int res1 = 0 ;
21276 PyObject *swig_obj[1] ;
21277
21278 if (!args) SWIG_fail;
21279 swig_obj[0] = args;
21280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21281 if (!SWIG_IsOK(res1)) {
21282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21283 }
21284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21285 result = (bool) ((arg1)->m_rightDown);
21286 {
21287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21288 }
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21298 bool arg2 ;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 bool val2 ;
21302 int ecode2 = 0 ;
21303 PyObject *swig_obj[2] ;
21304
21305 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21307 if (!SWIG_IsOK(res1)) {
21308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21309 }
21310 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21311 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21312 if (!SWIG_IsOK(ecode2)) {
21313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21314 }
21315 arg2 = static_cast< bool >(val2);
21316 if (arg1) (arg1)->m_controlDown = arg2;
21317
21318 resultobj = SWIG_Py_Void();
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21326 PyObject *resultobj = 0;
21327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21328 bool result;
21329 void *argp1 = 0 ;
21330 int res1 = 0 ;
21331 PyObject *swig_obj[1] ;
21332
21333 if (!args) SWIG_fail;
21334 swig_obj[0] = args;
21335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21336 if (!SWIG_IsOK(res1)) {
21337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21338 }
21339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21340 result = (bool) ((arg1)->m_controlDown);
21341 {
21342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21343 }
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21351 PyObject *resultobj = 0;
21352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21353 bool arg2 ;
21354 void *argp1 = 0 ;
21355 int res1 = 0 ;
21356 bool val2 ;
21357 int ecode2 = 0 ;
21358 PyObject *swig_obj[2] ;
21359
21360 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21362 if (!SWIG_IsOK(res1)) {
21363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21364 }
21365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21366 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21367 if (!SWIG_IsOK(ecode2)) {
21368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21369 }
21370 arg2 = static_cast< bool >(val2);
21371 if (arg1) (arg1)->m_shiftDown = arg2;
21372
21373 resultobj = SWIG_Py_Void();
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21381 PyObject *resultobj = 0;
21382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21383 bool result;
21384 void *argp1 = 0 ;
21385 int res1 = 0 ;
21386 PyObject *swig_obj[1] ;
21387
21388 if (!args) SWIG_fail;
21389 swig_obj[0] = args;
21390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21391 if (!SWIG_IsOK(res1)) {
21392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21393 }
21394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21395 result = (bool) ((arg1)->m_shiftDown);
21396 {
21397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21398 }
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21406 PyObject *resultobj = 0;
21407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21408 bool arg2 ;
21409 void *argp1 = 0 ;
21410 int res1 = 0 ;
21411 bool val2 ;
21412 int ecode2 = 0 ;
21413 PyObject *swig_obj[2] ;
21414
21415 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21417 if (!SWIG_IsOK(res1)) {
21418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21419 }
21420 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21421 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21422 if (!SWIG_IsOK(ecode2)) {
21423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21424 }
21425 arg2 = static_cast< bool >(val2);
21426 if (arg1) (arg1)->m_altDown = arg2;
21427
21428 resultobj = SWIG_Py_Void();
21429 return resultobj;
21430 fail:
21431 return NULL;
21432 }
21433
21434
21435 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21436 PyObject *resultobj = 0;
21437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21438 bool result;
21439 void *argp1 = 0 ;
21440 int res1 = 0 ;
21441 PyObject *swig_obj[1] ;
21442
21443 if (!args) SWIG_fail;
21444 swig_obj[0] = args;
21445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21448 }
21449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21450 result = (bool) ((arg1)->m_altDown);
21451 {
21452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21453 }
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21461 PyObject *resultobj = 0;
21462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21463 bool arg2 ;
21464 void *argp1 = 0 ;
21465 int res1 = 0 ;
21466 bool val2 ;
21467 int ecode2 = 0 ;
21468 PyObject *swig_obj[2] ;
21469
21470 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21474 }
21475 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21476 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21477 if (!SWIG_IsOK(ecode2)) {
21478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21479 }
21480 arg2 = static_cast< bool >(val2);
21481 if (arg1) (arg1)->m_metaDown = arg2;
21482
21483 resultobj = SWIG_Py_Void();
21484 return resultobj;
21485 fail:
21486 return NULL;
21487 }
21488
21489
21490 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21491 PyObject *resultobj = 0;
21492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21493 bool result;
21494 void *argp1 = 0 ;
21495 int res1 = 0 ;
21496 PyObject *swig_obj[1] ;
21497
21498 if (!args) SWIG_fail;
21499 swig_obj[0] = args;
21500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21501 if (!SWIG_IsOK(res1)) {
21502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21503 }
21504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21505 result = (bool) ((arg1)->m_metaDown);
21506 {
21507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21508 }
21509 return resultobj;
21510 fail:
21511 return NULL;
21512 }
21513
21514
21515 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21516 PyObject *resultobj = 0;
21517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21518 int arg2 ;
21519 void *argp1 = 0 ;
21520 int res1 = 0 ;
21521 int val2 ;
21522 int ecode2 = 0 ;
21523 PyObject *swig_obj[2] ;
21524
21525 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21527 if (!SWIG_IsOK(res1)) {
21528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21529 }
21530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21531 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21532 if (!SWIG_IsOK(ecode2)) {
21533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21534 }
21535 arg2 = static_cast< int >(val2);
21536 if (arg1) (arg1)->m_wheelRotation = arg2;
21537
21538 resultobj = SWIG_Py_Void();
21539 return resultobj;
21540 fail:
21541 return NULL;
21542 }
21543
21544
21545 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21546 PyObject *resultobj = 0;
21547 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21548 int result;
21549 void *argp1 = 0 ;
21550 int res1 = 0 ;
21551 PyObject *swig_obj[1] ;
21552
21553 if (!args) SWIG_fail;
21554 swig_obj[0] = args;
21555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21556 if (!SWIG_IsOK(res1)) {
21557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21558 }
21559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21560 result = (int) ((arg1)->m_wheelRotation);
21561 resultobj = SWIG_From_int(static_cast< int >(result));
21562 return resultobj;
21563 fail:
21564 return NULL;
21565 }
21566
21567
21568 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21569 PyObject *resultobj = 0;
21570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21571 int arg2 ;
21572 void *argp1 = 0 ;
21573 int res1 = 0 ;
21574 int val2 ;
21575 int ecode2 = 0 ;
21576 PyObject *swig_obj[2] ;
21577
21578 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21580 if (!SWIG_IsOK(res1)) {
21581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21582 }
21583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21585 if (!SWIG_IsOK(ecode2)) {
21586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21587 }
21588 arg2 = static_cast< int >(val2);
21589 if (arg1) (arg1)->m_wheelDelta = arg2;
21590
21591 resultobj = SWIG_Py_Void();
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21599 PyObject *resultobj = 0;
21600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21601 int result;
21602 void *argp1 = 0 ;
21603 int res1 = 0 ;
21604 PyObject *swig_obj[1] ;
21605
21606 if (!args) SWIG_fail;
21607 swig_obj[0] = args;
21608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21609 if (!SWIG_IsOK(res1)) {
21610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21611 }
21612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21613 result = (int) ((arg1)->m_wheelDelta);
21614 resultobj = SWIG_From_int(static_cast< int >(result));
21615 return resultobj;
21616 fail:
21617 return NULL;
21618 }
21619
21620
21621 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21622 PyObject *resultobj = 0;
21623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21624 int arg2 ;
21625 void *argp1 = 0 ;
21626 int res1 = 0 ;
21627 int val2 ;
21628 int ecode2 = 0 ;
21629 PyObject *swig_obj[2] ;
21630
21631 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21633 if (!SWIG_IsOK(res1)) {
21634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21635 }
21636 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21637 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21638 if (!SWIG_IsOK(ecode2)) {
21639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21640 }
21641 arg2 = static_cast< int >(val2);
21642 if (arg1) (arg1)->m_linesPerAction = arg2;
21643
21644 resultobj = SWIG_Py_Void();
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21652 PyObject *resultobj = 0;
21653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21654 int result;
21655 void *argp1 = 0 ;
21656 int res1 = 0 ;
21657 PyObject *swig_obj[1] ;
21658
21659 if (!args) SWIG_fail;
21660 swig_obj[0] = args;
21661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21662 if (!SWIG_IsOK(res1)) {
21663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21664 }
21665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21666 result = (int) ((arg1)->m_linesPerAction);
21667 resultobj = SWIG_From_int(static_cast< int >(result));
21668 return resultobj;
21669 fail:
21670 return NULL;
21671 }
21672
21673
21674 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21675 PyObject *obj;
21676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21677 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21678 return SWIG_Py_Void();
21679 }
21680
21681 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21682 return SWIG_Python_InitShadowInstance(args);
21683 }
21684
21685 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj = 0;
21687 int arg1 = (int) 0 ;
21688 int arg2 = (int) 0 ;
21689 wxSetCursorEvent *result = 0 ;
21690 int val1 ;
21691 int ecode1 = 0 ;
21692 int val2 ;
21693 int ecode2 = 0 ;
21694 PyObject * obj0 = 0 ;
21695 PyObject * obj1 = 0 ;
21696 char * kwnames[] = {
21697 (char *) "x",(char *) "y", NULL
21698 };
21699
21700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21701 if (obj0) {
21702 ecode1 = SWIG_AsVal_int(obj0, &val1);
21703 if (!SWIG_IsOK(ecode1)) {
21704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21705 }
21706 arg1 = static_cast< int >(val1);
21707 }
21708 if (obj1) {
21709 ecode2 = SWIG_AsVal_int(obj1, &val2);
21710 if (!SWIG_IsOK(ecode2)) {
21711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21712 }
21713 arg2 = static_cast< int >(val2);
21714 }
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21718 wxPyEndAllowThreads(__tstate);
21719 if (PyErr_Occurred()) SWIG_fail;
21720 }
21721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21729 PyObject *resultobj = 0;
21730 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21731 int result;
21732 void *argp1 = 0 ;
21733 int res1 = 0 ;
21734 PyObject *swig_obj[1] ;
21735
21736 if (!args) SWIG_fail;
21737 swig_obj[0] = args;
21738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21739 if (!SWIG_IsOK(res1)) {
21740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21741 }
21742 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 resultobj = SWIG_From_int(static_cast< int >(result));
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *resultobj = 0;
21758 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21759 int result;
21760 void *argp1 = 0 ;
21761 int res1 = 0 ;
21762 PyObject *swig_obj[1] ;
21763
21764 if (!args) SWIG_fail;
21765 swig_obj[0] = args;
21766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21767 if (!SWIG_IsOK(res1)) {
21768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21769 }
21770 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = SWIG_From_int(static_cast< int >(result));
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21785 PyObject *resultobj = 0;
21786 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21787 wxCursor *arg2 = 0 ;
21788 void *argp1 = 0 ;
21789 int res1 = 0 ;
21790 void *argp2 = 0 ;
21791 int res2 = 0 ;
21792 PyObject * obj0 = 0 ;
21793 PyObject * obj1 = 0 ;
21794 char * kwnames[] = {
21795 (char *) "self",(char *) "cursor", NULL
21796 };
21797
21798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21800 if (!SWIG_IsOK(res1)) {
21801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21802 }
21803 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21805 if (!SWIG_IsOK(res2)) {
21806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21807 }
21808 if (!argp2) {
21809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21810 }
21811 arg2 = reinterpret_cast< wxCursor * >(argp2);
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 (arg1)->SetCursor((wxCursor const &)*arg2);
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 resultobj = SWIG_Py_Void();
21819 return resultobj;
21820 fail:
21821 return NULL;
21822 }
21823
21824
21825 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21826 PyObject *resultobj = 0;
21827 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21828 wxCursor *result = 0 ;
21829 void *argp1 = 0 ;
21830 int res1 = 0 ;
21831 PyObject *swig_obj[1] ;
21832
21833 if (!args) SWIG_fail;
21834 swig_obj[0] = args;
21835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21838 }
21839 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 {
21843 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21844 result = (wxCursor *) &_result_ref;
21845 }
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 {
21850 wxCursor* resultptr = new wxCursor(*result);
21851 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21852 }
21853 return resultobj;
21854 fail:
21855 return NULL;
21856 }
21857
21858
21859 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21860 PyObject *resultobj = 0;
21861 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21862 bool result;
21863 void *argp1 = 0 ;
21864 int res1 = 0 ;
21865 PyObject *swig_obj[1] ;
21866
21867 if (!args) SWIG_fail;
21868 swig_obj[0] = args;
21869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21870 if (!SWIG_IsOK(res1)) {
21871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21872 }
21873 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21874 {
21875 PyThreadState* __tstate = wxPyBeginAllowThreads();
21876 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 {
21881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21882 }
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21890 PyObject *obj;
21891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21892 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21893 return SWIG_Py_Void();
21894 }
21895
21896 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21897 return SWIG_Python_InitShadowInstance(args);
21898 }
21899
21900 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21901 PyObject *resultobj = 0;
21902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21903 wxKeyEvent *result = 0 ;
21904 int val1 ;
21905 int ecode1 = 0 ;
21906 PyObject * obj0 = 0 ;
21907 char * kwnames[] = {
21908 (char *) "eventType", NULL
21909 };
21910
21911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21912 if (obj0) {
21913 ecode1 = SWIG_AsVal_int(obj0, &val1);
21914 if (!SWIG_IsOK(ecode1)) {
21915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21916 }
21917 arg1 = static_cast< wxEventType >(val1);
21918 }
21919 {
21920 PyThreadState* __tstate = wxPyBeginAllowThreads();
21921 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21922 wxPyEndAllowThreads(__tstate);
21923 if (PyErr_Occurred()) SWIG_fail;
21924 }
21925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933 PyObject *resultobj = 0;
21934 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21935 int result;
21936 void *argp1 = 0 ;
21937 int res1 = 0 ;
21938 PyObject *swig_obj[1] ;
21939
21940 if (!args) SWIG_fail;
21941 swig_obj[0] = args;
21942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21943 if (!SWIG_IsOK(res1)) {
21944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21945 }
21946 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 resultobj = SWIG_From_int(static_cast< int >(result));
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21961 PyObject *resultobj = 0;
21962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21963 bool result;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 PyObject *swig_obj[1] ;
21967
21968 if (!args) SWIG_fail;
21969 swig_obj[0] = args;
21970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21971 if (!SWIG_IsOK(res1)) {
21972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21973 }
21974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21975 {
21976 PyThreadState* __tstate = wxPyBeginAllowThreads();
21977 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21978 wxPyEndAllowThreads(__tstate);
21979 if (PyErr_Occurred()) SWIG_fail;
21980 }
21981 {
21982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21983 }
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21991 PyObject *resultobj = 0;
21992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21993 bool result;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 PyObject *swig_obj[1] ;
21997
21998 if (!args) SWIG_fail;
21999 swig_obj[0] = args;
22000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22003 }
22004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22005 {
22006 PyThreadState* __tstate = wxPyBeginAllowThreads();
22007 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22008 wxPyEndAllowThreads(__tstate);
22009 if (PyErr_Occurred()) SWIG_fail;
22010 }
22011 {
22012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22013 }
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22023 bool result;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 PyObject *swig_obj[1] ;
22027
22028 if (!args) SWIG_fail;
22029 swig_obj[0] = args;
22030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22033 }
22034 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 {
22042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22053 bool result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 {
22072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22073 }
22074 return resultobj;
22075 fail:
22076 return NULL;
22077 }
22078
22079
22080 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22081 PyObject *resultobj = 0;
22082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22083 bool result;
22084 void *argp1 = 0 ;
22085 int res1 = 0 ;
22086 PyObject *swig_obj[1] ;
22087
22088 if (!args) SWIG_fail;
22089 swig_obj[0] = args;
22090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22091 if (!SWIG_IsOK(res1)) {
22092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22093 }
22094 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 {
22102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22103 }
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22111 PyObject *resultobj = 0;
22112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22113 bool result;
22114 void *argp1 = 0 ;
22115 int res1 = 0 ;
22116 PyObject *swig_obj[1] ;
22117
22118 if (!args) SWIG_fail;
22119 swig_obj[0] = args;
22120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22121 if (!SWIG_IsOK(res1)) {
22122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22123 }
22124 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 {
22132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22133 }
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22141 PyObject *resultobj = 0;
22142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22143 int result;
22144 void *argp1 = 0 ;
22145 int res1 = 0 ;
22146 PyObject *swig_obj[1] ;
22147
22148 if (!args) SWIG_fail;
22149 swig_obj[0] = args;
22150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22151 if (!SWIG_IsOK(res1)) {
22152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22153 }
22154 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22155 {
22156 PyThreadState* __tstate = wxPyBeginAllowThreads();
22157 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22158 wxPyEndAllowThreads(__tstate);
22159 if (PyErr_Occurred()) SWIG_fail;
22160 }
22161 resultobj = SWIG_From_int(static_cast< int >(result));
22162 return resultobj;
22163 fail:
22164 return NULL;
22165 }
22166
22167
22168 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22169 PyObject *resultobj = 0;
22170 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22171 int result;
22172 void *argp1 = 0 ;
22173 int res1 = 0 ;
22174 PyObject *swig_obj[1] ;
22175
22176 if (!args) SWIG_fail;
22177 swig_obj[0] = args;
22178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22179 if (!SWIG_IsOK(res1)) {
22180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22181 }
22182 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_From_int(static_cast< int >(result));
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22197 PyObject *resultobj = 0;
22198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22199 int arg2 ;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 int val2 ;
22203 int ecode2 = 0 ;
22204 PyObject * obj0 = 0 ;
22205 PyObject * obj1 = 0 ;
22206 char * kwnames[] = {
22207 (char *) "self",(char *) "uniChar", NULL
22208 };
22209
22210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22212 if (!SWIG_IsOK(res1)) {
22213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22214 }
22215 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22216 ecode2 = SWIG_AsVal_int(obj1, &val2);
22217 if (!SWIG_IsOK(ecode2)) {
22218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22219 }
22220 arg2 = static_cast< int >(val2);
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 resultobj = SWIG_Py_Void();
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 PyObject *resultobj = 0;
22236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22237 unsigned int result;
22238 void *argp1 = 0 ;
22239 int res1 = 0 ;
22240 PyObject *swig_obj[1] ;
22241
22242 if (!args) SWIG_fail;
22243 swig_obj[0] = args;
22244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22245 if (!SWIG_IsOK(res1)) {
22246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22247 }
22248 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22263 PyObject *resultobj = 0;
22264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22265 unsigned int result;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 PyObject *swig_obj[1] ;
22269
22270 if (!args) SWIG_fail;
22271 swig_obj[0] = args;
22272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22275 }
22276 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22284 return resultobj;
22285 fail:
22286 return NULL;
22287 }
22288
22289
22290 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22291 PyObject *resultobj = 0;
22292 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22293 wxPoint result;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 PyObject *swig_obj[1] ;
22297
22298 if (!args) SWIG_fail;
22299 swig_obj[0] = args;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (arg1)->GetPosition();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22319 PyObject *resultobj = 0;
22320 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22321 long *arg2 = (long *) 0 ;
22322 long *arg3 = (long *) 0 ;
22323 void *argp1 = 0 ;
22324 int res1 = 0 ;
22325 long temp2 ;
22326 int res2 = SWIG_TMPOBJ ;
22327 long temp3 ;
22328 int res3 = SWIG_TMPOBJ ;
22329 PyObject *swig_obj[1] ;
22330
22331 arg2 = &temp2;
22332 arg3 = &temp3;
22333 if (!args) SWIG_fail;
22334 swig_obj[0] = args;
22335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22336 if (!SWIG_IsOK(res1)) {
22337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22338 }
22339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 (arg1)->GetPosition(arg2,arg3);
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 resultobj = SWIG_Py_Void();
22347 if (SWIG_IsTmpObj(res2)) {
22348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22349 } else {
22350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22352 }
22353 if (SWIG_IsTmpObj(res3)) {
22354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22355 } else {
22356 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22358 }
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22366 PyObject *resultobj = 0;
22367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22368 int result;
22369 void *argp1 = 0 ;
22370 int res1 = 0 ;
22371 PyObject *swig_obj[1] ;
22372
22373 if (!args) SWIG_fail;
22374 swig_obj[0] = args;
22375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22376 if (!SWIG_IsOK(res1)) {
22377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22378 }
22379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22380 {
22381 PyThreadState* __tstate = wxPyBeginAllowThreads();
22382 result = (int)((wxKeyEvent const *)arg1)->GetX();
22383 wxPyEndAllowThreads(__tstate);
22384 if (PyErr_Occurred()) SWIG_fail;
22385 }
22386 resultobj = SWIG_From_int(static_cast< int >(result));
22387 return resultobj;
22388 fail:
22389 return NULL;
22390 }
22391
22392
22393 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22394 PyObject *resultobj = 0;
22395 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22396 int result;
22397 void *argp1 = 0 ;
22398 int res1 = 0 ;
22399 PyObject *swig_obj[1] ;
22400
22401 if (!args) SWIG_fail;
22402 swig_obj[0] = args;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22406 }
22407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = (int)((wxKeyEvent const *)arg1)->GetY();
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_From_int(static_cast< int >(result));
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422 PyObject *resultobj = 0;
22423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22424 int arg2 ;
22425 void *argp1 = 0 ;
22426 int res1 = 0 ;
22427 int val2 ;
22428 int ecode2 = 0 ;
22429 PyObject *swig_obj[2] ;
22430
22431 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22433 if (!SWIG_IsOK(res1)) {
22434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22435 }
22436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22438 if (!SWIG_IsOK(ecode2)) {
22439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22440 }
22441 arg2 = static_cast< int >(val2);
22442 if (arg1) (arg1)->m_x = arg2;
22443
22444 resultobj = SWIG_Py_Void();
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22454 int result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22464 }
22465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22466 result = (int) ((arg1)->m_x);
22467 resultobj = SWIG_From_int(static_cast< int >(result));
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22475 PyObject *resultobj = 0;
22476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22477 int arg2 ;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 int val2 ;
22481 int ecode2 = 0 ;
22482 PyObject *swig_obj[2] ;
22483
22484 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22486 if (!SWIG_IsOK(res1)) {
22487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22488 }
22489 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22490 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22491 if (!SWIG_IsOK(ecode2)) {
22492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22493 }
22494 arg2 = static_cast< int >(val2);
22495 if (arg1) (arg1)->m_y = arg2;
22496
22497 resultobj = SWIG_Py_Void();
22498 return resultobj;
22499 fail:
22500 return NULL;
22501 }
22502
22503
22504 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22505 PyObject *resultobj = 0;
22506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22507 int result;
22508 void *argp1 = 0 ;
22509 int res1 = 0 ;
22510 PyObject *swig_obj[1] ;
22511
22512 if (!args) SWIG_fail;
22513 swig_obj[0] = args;
22514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22515 if (!SWIG_IsOK(res1)) {
22516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22517 }
22518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22519 result = (int) ((arg1)->m_y);
22520 resultobj = SWIG_From_int(static_cast< int >(result));
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 long arg2 ;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 long val2 ;
22534 int ecode2 = 0 ;
22535 PyObject *swig_obj[2] ;
22536
22537 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22541 }
22542 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22543 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22544 if (!SWIG_IsOK(ecode2)) {
22545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22546 }
22547 arg2 = static_cast< long >(val2);
22548 if (arg1) (arg1)->m_keyCode = arg2;
22549
22550 resultobj = SWIG_Py_Void();
22551 return resultobj;
22552 fail:
22553 return NULL;
22554 }
22555
22556
22557 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22558 PyObject *resultobj = 0;
22559 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22560 long result;
22561 void *argp1 = 0 ;
22562 int res1 = 0 ;
22563 PyObject *swig_obj[1] ;
22564
22565 if (!args) SWIG_fail;
22566 swig_obj[0] = args;
22567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22568 if (!SWIG_IsOK(res1)) {
22569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22570 }
22571 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22572 result = (long) ((arg1)->m_keyCode);
22573 resultobj = SWIG_From_long(static_cast< long >(result));
22574 return resultobj;
22575 fail:
22576 return NULL;
22577 }
22578
22579
22580 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22581 PyObject *resultobj = 0;
22582 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22583 bool arg2 ;
22584 void *argp1 = 0 ;
22585 int res1 = 0 ;
22586 bool val2 ;
22587 int ecode2 = 0 ;
22588 PyObject *swig_obj[2] ;
22589
22590 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22592 if (!SWIG_IsOK(res1)) {
22593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22594 }
22595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22596 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22597 if (!SWIG_IsOK(ecode2)) {
22598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22599 }
22600 arg2 = static_cast< bool >(val2);
22601 if (arg1) (arg1)->m_controlDown = arg2;
22602
22603 resultobj = SWIG_Py_Void();
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22611 PyObject *resultobj = 0;
22612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22613 bool result;
22614 void *argp1 = 0 ;
22615 int res1 = 0 ;
22616 PyObject *swig_obj[1] ;
22617
22618 if (!args) SWIG_fail;
22619 swig_obj[0] = args;
22620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22621 if (!SWIG_IsOK(res1)) {
22622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22623 }
22624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22625 result = (bool) ((arg1)->m_controlDown);
22626 {
22627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22628 }
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22636 PyObject *resultobj = 0;
22637 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22638 bool arg2 ;
22639 void *argp1 = 0 ;
22640 int res1 = 0 ;
22641 bool val2 ;
22642 int ecode2 = 0 ;
22643 PyObject *swig_obj[2] ;
22644
22645 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22649 }
22650 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22651 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22652 if (!SWIG_IsOK(ecode2)) {
22653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22654 }
22655 arg2 = static_cast< bool >(val2);
22656 if (arg1) (arg1)->m_shiftDown = arg2;
22657
22658 resultobj = SWIG_Py_Void();
22659 return resultobj;
22660 fail:
22661 return NULL;
22662 }
22663
22664
22665 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22666 PyObject *resultobj = 0;
22667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22668 bool result;
22669 void *argp1 = 0 ;
22670 int res1 = 0 ;
22671 PyObject *swig_obj[1] ;
22672
22673 if (!args) SWIG_fail;
22674 swig_obj[0] = args;
22675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22676 if (!SWIG_IsOK(res1)) {
22677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22678 }
22679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22680 result = (bool) ((arg1)->m_shiftDown);
22681 {
22682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22683 }
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22691 PyObject *resultobj = 0;
22692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22693 bool arg2 ;
22694 void *argp1 = 0 ;
22695 int res1 = 0 ;
22696 bool val2 ;
22697 int ecode2 = 0 ;
22698 PyObject *swig_obj[2] ;
22699
22700 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22704 }
22705 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22706 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22707 if (!SWIG_IsOK(ecode2)) {
22708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22709 }
22710 arg2 = static_cast< bool >(val2);
22711 if (arg1) (arg1)->m_altDown = arg2;
22712
22713 resultobj = SWIG_Py_Void();
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22721 PyObject *resultobj = 0;
22722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22723 bool result;
22724 void *argp1 = 0 ;
22725 int res1 = 0 ;
22726 PyObject *swig_obj[1] ;
22727
22728 if (!args) SWIG_fail;
22729 swig_obj[0] = args;
22730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22731 if (!SWIG_IsOK(res1)) {
22732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22733 }
22734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22735 result = (bool) ((arg1)->m_altDown);
22736 {
22737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22738 }
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22748 bool arg2 ;
22749 void *argp1 = 0 ;
22750 int res1 = 0 ;
22751 bool val2 ;
22752 int ecode2 = 0 ;
22753 PyObject *swig_obj[2] ;
22754
22755 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22759 }
22760 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22761 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22762 if (!SWIG_IsOK(ecode2)) {
22763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22764 }
22765 arg2 = static_cast< bool >(val2);
22766 if (arg1) (arg1)->m_metaDown = arg2;
22767
22768 resultobj = SWIG_Py_Void();
22769 return resultobj;
22770 fail:
22771 return NULL;
22772 }
22773
22774
22775 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 PyObject *resultobj = 0;
22777 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22778 bool result;
22779 void *argp1 = 0 ;
22780 int res1 = 0 ;
22781 PyObject *swig_obj[1] ;
22782
22783 if (!args) SWIG_fail;
22784 swig_obj[0] = args;
22785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22786 if (!SWIG_IsOK(res1)) {
22787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22788 }
22789 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22790 result = (bool) ((arg1)->m_metaDown);
22791 {
22792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22793 }
22794 return resultobj;
22795 fail:
22796 return NULL;
22797 }
22798
22799
22800 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22801 PyObject *resultobj = 0;
22802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22803 bool arg2 ;
22804 void *argp1 = 0 ;
22805 int res1 = 0 ;
22806 bool val2 ;
22807 int ecode2 = 0 ;
22808 PyObject *swig_obj[2] ;
22809
22810 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22814 }
22815 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22816 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22817 if (!SWIG_IsOK(ecode2)) {
22818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22819 }
22820 arg2 = static_cast< bool >(val2);
22821 if (arg1) (arg1)->m_scanCode = arg2;
22822
22823 resultobj = SWIG_Py_Void();
22824 return resultobj;
22825 fail:
22826 return NULL;
22827 }
22828
22829
22830 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22831 PyObject *resultobj = 0;
22832 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22833 bool result;
22834 void *argp1 = 0 ;
22835 int res1 = 0 ;
22836 PyObject *swig_obj[1] ;
22837
22838 if (!args) SWIG_fail;
22839 swig_obj[0] = args;
22840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22841 if (!SWIG_IsOK(res1)) {
22842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22843 }
22844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22845 result = (bool) ((arg1)->m_scanCode);
22846 {
22847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22848 }
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22858 unsigned int arg2 ;
22859 void *argp1 = 0 ;
22860 int res1 = 0 ;
22861 unsigned int val2 ;
22862 int ecode2 = 0 ;
22863 PyObject *swig_obj[2] ;
22864
22865 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22869 }
22870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22871 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22872 if (!SWIG_IsOK(ecode2)) {
22873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22874 }
22875 arg2 = static_cast< unsigned int >(val2);
22876 if (arg1) (arg1)->m_rawCode = arg2;
22877
22878 resultobj = SWIG_Py_Void();
22879 return resultobj;
22880 fail:
22881 return NULL;
22882 }
22883
22884
22885 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 PyObject *resultobj = 0;
22887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22888 unsigned int result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 PyObject *swig_obj[1] ;
22892
22893 if (!args) SWIG_fail;
22894 swig_obj[0] = args;
22895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22898 }
22899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22900 result = (unsigned int) ((arg1)->m_rawCode);
22901 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22902 return resultobj;
22903 fail:
22904 return NULL;
22905 }
22906
22907
22908 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22909 PyObject *resultobj = 0;
22910 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22911 unsigned int arg2 ;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 unsigned int val2 ;
22915 int ecode2 = 0 ;
22916 PyObject *swig_obj[2] ;
22917
22918 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22920 if (!SWIG_IsOK(res1)) {
22921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22922 }
22923 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22924 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22925 if (!SWIG_IsOK(ecode2)) {
22926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22927 }
22928 arg2 = static_cast< unsigned int >(val2);
22929 if (arg1) (arg1)->m_rawFlags = arg2;
22930
22931 resultobj = SWIG_Py_Void();
22932 return resultobj;
22933 fail:
22934 return NULL;
22935 }
22936
22937
22938 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22939 PyObject *resultobj = 0;
22940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22941 unsigned int result;
22942 void *argp1 = 0 ;
22943 int res1 = 0 ;
22944 PyObject *swig_obj[1] ;
22945
22946 if (!args) SWIG_fail;
22947 swig_obj[0] = args;
22948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22949 if (!SWIG_IsOK(res1)) {
22950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22951 }
22952 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22953 result = (unsigned int) ((arg1)->m_rawFlags);
22954 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22962 PyObject *obj;
22963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22964 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22965 return SWIG_Py_Void();
22966 }
22967
22968 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22969 return SWIG_Python_InitShadowInstance(args);
22970 }
22971
22972 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj = 0;
22974 wxSize const &arg1_defvalue = wxDefaultSize ;
22975 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22976 int arg2 = (int) 0 ;
22977 wxSizeEvent *result = 0 ;
22978 wxSize temp1 ;
22979 int val2 ;
22980 int ecode2 = 0 ;
22981 PyObject * obj0 = 0 ;
22982 PyObject * obj1 = 0 ;
22983 char * kwnames[] = {
22984 (char *) "sz",(char *) "winid", NULL
22985 };
22986
22987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22988 if (obj0) {
22989 {
22990 arg1 = &temp1;
22991 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22992 }
22993 }
22994 if (obj1) {
22995 ecode2 = SWIG_AsVal_int(obj1, &val2);
22996 if (!SWIG_IsOK(ecode2)) {
22997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22998 }
22999 arg2 = static_cast< int >(val2);
23000 }
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23017 wxSize result;
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_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23027 }
23028 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 result = ((wxSizeEvent const *)arg1)->GetSize();
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23043 PyObject *resultobj = 0;
23044 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23045 wxRect result;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 PyObject *swig_obj[1] ;
23049
23050 if (!args) SWIG_fail;
23051 swig_obj[0] = args;
23052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23053 if (!SWIG_IsOK(res1)) {
23054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23055 }
23056 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 result = ((wxSizeEvent const *)arg1)->GetRect();
23060 wxPyEndAllowThreads(__tstate);
23061 if (PyErr_Occurred()) SWIG_fail;
23062 }
23063 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj = 0;
23072 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23073 wxRect arg2 ;
23074 void *argp1 = 0 ;
23075 int res1 = 0 ;
23076 void *argp2 ;
23077 int res2 = 0 ;
23078 PyObject * obj0 = 0 ;
23079 PyObject * obj1 = 0 ;
23080 char * kwnames[] = {
23081 (char *) "self",(char *) "rect", NULL
23082 };
23083
23084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23086 if (!SWIG_IsOK(res1)) {
23087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23088 }
23089 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23090 {
23091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23092 if (!SWIG_IsOK(res2)) {
23093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23094 }
23095 if (!argp2) {
23096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23097 } else {
23098 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23099 arg2 = *temp;
23100 if (SWIG_IsNewObj(res2)) delete temp;
23101 }
23102 }
23103 {
23104 PyThreadState* __tstate = wxPyBeginAllowThreads();
23105 (arg1)->SetRect(arg2);
23106 wxPyEndAllowThreads(__tstate);
23107 if (PyErr_Occurred()) SWIG_fail;
23108 }
23109 resultobj = SWIG_Py_Void();
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj = 0;
23118 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23119 wxSize arg2 ;
23120 void *argp1 = 0 ;
23121 int res1 = 0 ;
23122 void *argp2 ;
23123 int res2 = 0 ;
23124 PyObject * obj0 = 0 ;
23125 PyObject * obj1 = 0 ;
23126 char * kwnames[] = {
23127 (char *) "self",(char *) "size", NULL
23128 };
23129
23130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23134 }
23135 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23136 {
23137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23138 if (!SWIG_IsOK(res2)) {
23139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23140 }
23141 if (!argp2) {
23142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23143 } else {
23144 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23145 arg2 = *temp;
23146 if (SWIG_IsNewObj(res2)) delete temp;
23147 }
23148 }
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 wxSizeEvent_SetSize(arg1,arg2);
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 resultobj = SWIG_Py_Void();
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23163 PyObject *resultobj = 0;
23164 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23165 wxSize *arg2 = (wxSize *) 0 ;
23166 void *argp1 = 0 ;
23167 int res1 = 0 ;
23168 void *argp2 = 0 ;
23169 int res2 = 0 ;
23170 PyObject *swig_obj[2] ;
23171
23172 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23174 if (!SWIG_IsOK(res1)) {
23175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23176 }
23177 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23178 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23179 if (!SWIG_IsOK(res2)) {
23180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23181 }
23182 arg2 = reinterpret_cast< wxSize * >(argp2);
23183 if (arg1) (arg1)->m_size = *arg2;
23184
23185 resultobj = SWIG_Py_Void();
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23193 PyObject *resultobj = 0;
23194 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23195 wxSize *result = 0 ;
23196 void *argp1 = 0 ;
23197 int res1 = 0 ;
23198 PyObject *swig_obj[1] ;
23199
23200 if (!args) SWIG_fail;
23201 swig_obj[0] = args;
23202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23203 if (!SWIG_IsOK(res1)) {
23204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23205 }
23206 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23207 result = (wxSize *)& ((arg1)->m_size);
23208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23209 return resultobj;
23210 fail:
23211 return NULL;
23212 }
23213
23214
23215 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23216 PyObject *resultobj = 0;
23217 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23218 wxRect *arg2 = (wxRect *) 0 ;
23219 void *argp1 = 0 ;
23220 int res1 = 0 ;
23221 void *argp2 = 0 ;
23222 int res2 = 0 ;
23223 PyObject *swig_obj[2] ;
23224
23225 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23229 }
23230 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23231 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23232 if (!SWIG_IsOK(res2)) {
23233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23234 }
23235 arg2 = reinterpret_cast< wxRect * >(argp2);
23236 if (arg1) (arg1)->m_rect = *arg2;
23237
23238 resultobj = SWIG_Py_Void();
23239 return resultobj;
23240 fail:
23241 return NULL;
23242 }
23243
23244
23245 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23246 PyObject *resultobj = 0;
23247 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23248 wxRect *result = 0 ;
23249 void *argp1 = 0 ;
23250 int res1 = 0 ;
23251 PyObject *swig_obj[1] ;
23252
23253 if (!args) SWIG_fail;
23254 swig_obj[0] = args;
23255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23256 if (!SWIG_IsOK(res1)) {
23257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23258 }
23259 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23260 result = (wxRect *)& ((arg1)->m_rect);
23261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23262 return resultobj;
23263 fail:
23264 return NULL;
23265 }
23266
23267
23268 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23269 PyObject *obj;
23270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23271 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23272 return SWIG_Py_Void();
23273 }
23274
23275 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23276 return SWIG_Python_InitShadowInstance(args);
23277 }
23278
23279 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23282 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23283 int arg2 = (int) 0 ;
23284 wxMoveEvent *result = 0 ;
23285 wxPoint temp1 ;
23286 int val2 ;
23287 int ecode2 = 0 ;
23288 PyObject * obj0 = 0 ;
23289 PyObject * obj1 = 0 ;
23290 char * kwnames[] = {
23291 (char *) "pos",(char *) "winid", NULL
23292 };
23293
23294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23295 if (obj0) {
23296 {
23297 arg1 = &temp1;
23298 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23299 }
23300 }
23301 if (obj1) {
23302 ecode2 = SWIG_AsVal_int(obj1, &val2);
23303 if (!SWIG_IsOK(ecode2)) {
23304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23305 }
23306 arg2 = static_cast< int >(val2);
23307 }
23308 {
23309 PyThreadState* __tstate = wxPyBeginAllowThreads();
23310 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23311 wxPyEndAllowThreads(__tstate);
23312 if (PyErr_Occurred()) SWIG_fail;
23313 }
23314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 PyObject *resultobj = 0;
23323 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23324 wxPoint result;
23325 void *argp1 = 0 ;
23326 int res1 = 0 ;
23327 PyObject *swig_obj[1] ;
23328
23329 if (!args) SWIG_fail;
23330 swig_obj[0] = args;
23331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23332 if (!SWIG_IsOK(res1)) {
23333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23334 }
23335 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = ((wxMoveEvent const *)arg1)->GetPosition();
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 PyObject *resultobj = 0;
23351 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23352 wxRect result;
23353 void *argp1 = 0 ;
23354 int res1 = 0 ;
23355 PyObject *swig_obj[1] ;
23356
23357 if (!args) SWIG_fail;
23358 swig_obj[0] = args;
23359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23360 if (!SWIG_IsOK(res1)) {
23361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23362 }
23363 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23364 {
23365 PyThreadState* __tstate = wxPyBeginAllowThreads();
23366 result = ((wxMoveEvent const *)arg1)->GetRect();
23367 wxPyEndAllowThreads(__tstate);
23368 if (PyErr_Occurred()) SWIG_fail;
23369 }
23370 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj = 0;
23379 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23380 wxRect *arg2 = 0 ;
23381 void *argp1 = 0 ;
23382 int res1 = 0 ;
23383 wxRect temp2 ;
23384 PyObject * obj0 = 0 ;
23385 PyObject * obj1 = 0 ;
23386 char * kwnames[] = {
23387 (char *) "self",(char *) "rect", NULL
23388 };
23389
23390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23394 }
23395 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23396 {
23397 arg2 = &temp2;
23398 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23399 }
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 (arg1)->SetRect((wxRect const &)*arg2);
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 resultobj = SWIG_Py_Void();
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj = 0;
23415 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23416 wxPoint *arg2 = 0 ;
23417 void *argp1 = 0 ;
23418 int res1 = 0 ;
23419 wxPoint temp2 ;
23420 PyObject * obj0 = 0 ;
23421 PyObject * obj1 = 0 ;
23422 char * kwnames[] = {
23423 (char *) "self",(char *) "pos", NULL
23424 };
23425
23426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23428 if (!SWIG_IsOK(res1)) {
23429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23430 }
23431 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23432 {
23433 arg2 = &temp2;
23434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23435 }
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 (arg1)->SetPosition((wxPoint const &)*arg2);
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 resultobj = SWIG_Py_Void();
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23450 PyObject *obj;
23451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23452 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23453 return SWIG_Py_Void();
23454 }
23455
23456 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 return SWIG_Python_InitShadowInstance(args);
23458 }
23459
23460 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj = 0;
23462 int arg1 = (int) 0 ;
23463 wxPaintEvent *result = 0 ;
23464 int val1 ;
23465 int ecode1 = 0 ;
23466 PyObject * obj0 = 0 ;
23467 char * kwnames[] = {
23468 (char *) "Id", NULL
23469 };
23470
23471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23472 if (obj0) {
23473 ecode1 = SWIG_AsVal_int(obj0, &val1);
23474 if (!SWIG_IsOK(ecode1)) {
23475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23476 }
23477 arg1 = static_cast< int >(val1);
23478 }
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23493 PyObject *obj;
23494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23495 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23496 return SWIG_Py_Void();
23497 }
23498
23499 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23500 return SWIG_Python_InitShadowInstance(args);
23501 }
23502
23503 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23504 PyObject *resultobj = 0;
23505 int arg1 = (int) 0 ;
23506 wxNcPaintEvent *result = 0 ;
23507 int val1 ;
23508 int ecode1 = 0 ;
23509 PyObject * obj0 = 0 ;
23510 char * kwnames[] = {
23511 (char *) "winid", NULL
23512 };
23513
23514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23515 if (obj0) {
23516 ecode1 = SWIG_AsVal_int(obj0, &val1);
23517 if (!SWIG_IsOK(ecode1)) {
23518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23519 }
23520 arg1 = static_cast< int >(val1);
23521 }
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23536 PyObject *obj;
23537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23538 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23539 return SWIG_Py_Void();
23540 }
23541
23542 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23543 return SWIG_Python_InitShadowInstance(args);
23544 }
23545
23546 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = 0;
23548 int arg1 = (int) 0 ;
23549 wxDC *arg2 = (wxDC *) NULL ;
23550 wxEraseEvent *result = 0 ;
23551 int val1 ;
23552 int ecode1 = 0 ;
23553 void *argp2 = 0 ;
23554 int res2 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 PyObject * obj1 = 0 ;
23557 char * kwnames[] = {
23558 (char *) "Id",(char *) "dc", NULL
23559 };
23560
23561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23562 if (obj0) {
23563 ecode1 = SWIG_AsVal_int(obj0, &val1);
23564 if (!SWIG_IsOK(ecode1)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23566 }
23567 arg1 = static_cast< int >(val1);
23568 }
23569 if (obj1) {
23570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23571 if (!SWIG_IsOK(res2)) {
23572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23573 }
23574 arg2 = reinterpret_cast< wxDC * >(argp2);
23575 }
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23590 PyObject *resultobj = 0;
23591 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23592 wxDC *result = 0 ;
23593 void *argp1 = 0 ;
23594 int res1 = 0 ;
23595 PyObject *swig_obj[1] ;
23596
23597 if (!args) SWIG_fail;
23598 swig_obj[0] = args;
23599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23600 if (!SWIG_IsOK(res1)) {
23601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23602 }
23603 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 resultobj = wxPyMake_wxObject(result, (bool)0);
23612 }
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23620 PyObject *obj;
23621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23622 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23623 return SWIG_Py_Void();
23624 }
23625
23626 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23627 return SWIG_Python_InitShadowInstance(args);
23628 }
23629
23630 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23633 int arg2 = (int) 0 ;
23634 wxFocusEvent *result = 0 ;
23635 int val1 ;
23636 int ecode1 = 0 ;
23637 int val2 ;
23638 int ecode2 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 PyObject * obj1 = 0 ;
23641 char * kwnames[] = {
23642 (char *) "type",(char *) "winid", NULL
23643 };
23644
23645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23646 if (obj0) {
23647 ecode1 = SWIG_AsVal_int(obj0, &val1);
23648 if (!SWIG_IsOK(ecode1)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23650 }
23651 arg1 = static_cast< wxEventType >(val1);
23652 }
23653 if (obj1) {
23654 ecode2 = SWIG_AsVal_int(obj1, &val2);
23655 if (!SWIG_IsOK(ecode2)) {
23656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23657 }
23658 arg2 = static_cast< int >(val2);
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23674 PyObject *resultobj = 0;
23675 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23676 wxWindow *result = 0 ;
23677 void *argp1 = 0 ;
23678 int res1 = 0 ;
23679 PyObject *swig_obj[1] ;
23680
23681 if (!args) SWIG_fail;
23682 swig_obj[0] = args;
23683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23684 if (!SWIG_IsOK(res1)) {
23685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23686 }
23687 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 resultobj = wxPyMake_wxObject(result, (bool)0);
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23704 PyObject *resultobj = 0;
23705 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23706 wxWindow *arg2 = (wxWindow *) 0 ;
23707 void *argp1 = 0 ;
23708 int res1 = 0 ;
23709 void *argp2 = 0 ;
23710 int res2 = 0 ;
23711 PyObject * obj0 = 0 ;
23712 PyObject * obj1 = 0 ;
23713 char * kwnames[] = {
23714 (char *) "self",(char *) "win", NULL
23715 };
23716
23717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23719 if (!SWIG_IsOK(res1)) {
23720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23721 }
23722 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23724 if (!SWIG_IsOK(res2)) {
23725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23726 }
23727 arg2 = reinterpret_cast< wxWindow * >(argp2);
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 (arg1)->SetWindow(arg2);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_Py_Void();
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *obj;
23743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23744 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23745 return SWIG_Py_Void();
23746 }
23747
23748 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23749 return SWIG_Python_InitShadowInstance(args);
23750 }
23751
23752 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj = 0;
23754 wxWindow *arg1 = (wxWindow *) NULL ;
23755 wxChildFocusEvent *result = 0 ;
23756 void *argp1 = 0 ;
23757 int res1 = 0 ;
23758 PyObject * obj0 = 0 ;
23759 char * kwnames[] = {
23760 (char *) "win", NULL
23761 };
23762
23763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23764 if (obj0) {
23765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23766 if (!SWIG_IsOK(res1)) {
23767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23768 }
23769 arg1 = reinterpret_cast< wxWindow * >(argp1);
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23787 wxWindow *result = 0 ;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 PyObject *swig_obj[1] ;
23791
23792 if (!args) SWIG_fail;
23793 swig_obj[0] = args;
23794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23795 if (!SWIG_IsOK(res1)) {
23796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23797 }
23798 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 resultobj = wxPyMake_wxObject(result, (bool)0);
23807 }
23808 return resultobj;
23809 fail:
23810 return NULL;
23811 }
23812
23813
23814 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23815 PyObject *obj;
23816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23817 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23818 return SWIG_Py_Void();
23819 }
23820
23821 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23822 return SWIG_Python_InitShadowInstance(args);
23823 }
23824
23825 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23826 PyObject *resultobj = 0;
23827 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23828 bool arg2 = (bool) true ;
23829 int arg3 = (int) 0 ;
23830 wxActivateEvent *result = 0 ;
23831 int val1 ;
23832 int ecode1 = 0 ;
23833 bool val2 ;
23834 int ecode2 = 0 ;
23835 int val3 ;
23836 int ecode3 = 0 ;
23837 PyObject * obj0 = 0 ;
23838 PyObject * obj1 = 0 ;
23839 PyObject * obj2 = 0 ;
23840 char * kwnames[] = {
23841 (char *) "type",(char *) "active",(char *) "Id", NULL
23842 };
23843
23844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23845 if (obj0) {
23846 ecode1 = SWIG_AsVal_int(obj0, &val1);
23847 if (!SWIG_IsOK(ecode1)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23849 }
23850 arg1 = static_cast< wxEventType >(val1);
23851 }
23852 if (obj1) {
23853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23854 if (!SWIG_IsOK(ecode2)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23856 }
23857 arg2 = static_cast< bool >(val2);
23858 }
23859 if (obj2) {
23860 ecode3 = SWIG_AsVal_int(obj2, &val3);
23861 if (!SWIG_IsOK(ecode3)) {
23862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23863 }
23864 arg3 = static_cast< int >(val3);
23865 }
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23880 PyObject *resultobj = 0;
23881 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23882 bool result;
23883 void *argp1 = 0 ;
23884 int res1 = 0 ;
23885 PyObject *swig_obj[1] ;
23886
23887 if (!args) SWIG_fail;
23888 swig_obj[0] = args;
23889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23890 if (!SWIG_IsOK(res1)) {
23891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23892 }
23893 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23894 {
23895 PyThreadState* __tstate = wxPyBeginAllowThreads();
23896 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 {
23901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23902 }
23903 return resultobj;
23904 fail:
23905 return NULL;
23906 }
23907
23908
23909 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23910 PyObject *obj;
23911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23912 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23913 return SWIG_Py_Void();
23914 }
23915
23916 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23917 return SWIG_Python_InitShadowInstance(args);
23918 }
23919
23920 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23921 PyObject *resultobj = 0;
23922 int arg1 = (int) 0 ;
23923 wxInitDialogEvent *result = 0 ;
23924 int val1 ;
23925 int ecode1 = 0 ;
23926 PyObject * obj0 = 0 ;
23927 char * kwnames[] = {
23928 (char *) "Id", NULL
23929 };
23930
23931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23932 if (obj0) {
23933 ecode1 = SWIG_AsVal_int(obj0, &val1);
23934 if (!SWIG_IsOK(ecode1)) {
23935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23936 }
23937 arg1 = static_cast< int >(val1);
23938 }
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23953 PyObject *obj;
23954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23955 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23956 return SWIG_Py_Void();
23957 }
23958
23959 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 return SWIG_Python_InitShadowInstance(args);
23961 }
23962
23963 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj = 0;
23965 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23966 int arg2 = (int) 0 ;
23967 wxMenu *arg3 = (wxMenu *) NULL ;
23968 wxMenuEvent *result = 0 ;
23969 int val1 ;
23970 int ecode1 = 0 ;
23971 int val2 ;
23972 int ecode2 = 0 ;
23973 void *argp3 = 0 ;
23974 int res3 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 PyObject * obj2 = 0 ;
23978 char * kwnames[] = {
23979 (char *) "type",(char *) "winid",(char *) "menu", NULL
23980 };
23981
23982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23983 if (obj0) {
23984 ecode1 = SWIG_AsVal_int(obj0, &val1);
23985 if (!SWIG_IsOK(ecode1)) {
23986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23987 }
23988 arg1 = static_cast< wxEventType >(val1);
23989 }
23990 if (obj1) {
23991 ecode2 = SWIG_AsVal_int(obj1, &val2);
23992 if (!SWIG_IsOK(ecode2)) {
23993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23994 }
23995 arg2 = static_cast< int >(val2);
23996 }
23997 if (obj2) {
23998 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23999 if (!SWIG_IsOK(res3)) {
24000 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24001 }
24002 arg3 = reinterpret_cast< wxMenu * >(argp3);
24003 }
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24011 return resultobj;
24012 fail:
24013 return NULL;
24014 }
24015
24016
24017 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24018 PyObject *resultobj = 0;
24019 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24020 int result;
24021 void *argp1 = 0 ;
24022 int res1 = 0 ;
24023 PyObject *swig_obj[1] ;
24024
24025 if (!args) SWIG_fail;
24026 swig_obj[0] = args;
24027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24028 if (!SWIG_IsOK(res1)) {
24029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24030 }
24031 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24035 wxPyEndAllowThreads(__tstate);
24036 if (PyErr_Occurred()) SWIG_fail;
24037 }
24038 resultobj = SWIG_From_int(static_cast< int >(result));
24039 return resultobj;
24040 fail:
24041 return NULL;
24042 }
24043
24044
24045 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24046 PyObject *resultobj = 0;
24047 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24048 bool result;
24049 void *argp1 = 0 ;
24050 int res1 = 0 ;
24051 PyObject *swig_obj[1] ;
24052
24053 if (!args) SWIG_fail;
24054 swig_obj[0] = args;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24058 }
24059 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24060 {
24061 PyThreadState* __tstate = wxPyBeginAllowThreads();
24062 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 {
24067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24068 }
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24076 PyObject *resultobj = 0;
24077 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24078 wxMenu *result = 0 ;
24079 void *argp1 = 0 ;
24080 int res1 = 0 ;
24081 PyObject *swig_obj[1] ;
24082
24083 if (!args) SWIG_fail;
24084 swig_obj[0] = args;
24085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24086 if (!SWIG_IsOK(res1)) {
24087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24088 }
24089 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24090 {
24091 PyThreadState* __tstate = wxPyBeginAllowThreads();
24092 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 {
24097 resultobj = wxPyMake_wxObject(result, (bool)0);
24098 }
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 PyObject *obj;
24107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24108 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24109 return SWIG_Py_Void();
24110 }
24111
24112 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24113 return SWIG_Python_InitShadowInstance(args);
24114 }
24115
24116 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj = 0;
24118 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24119 int arg2 = (int) 0 ;
24120 wxCloseEvent *result = 0 ;
24121 int val1 ;
24122 int ecode1 = 0 ;
24123 int val2 ;
24124 int ecode2 = 0 ;
24125 PyObject * obj0 = 0 ;
24126 PyObject * obj1 = 0 ;
24127 char * kwnames[] = {
24128 (char *) "type",(char *) "winid", NULL
24129 };
24130
24131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24132 if (obj0) {
24133 ecode1 = SWIG_AsVal_int(obj0, &val1);
24134 if (!SWIG_IsOK(ecode1)) {
24135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24136 }
24137 arg1 = static_cast< wxEventType >(val1);
24138 }
24139 if (obj1) {
24140 ecode2 = SWIG_AsVal_int(obj1, &val2);
24141 if (!SWIG_IsOK(ecode2)) {
24142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24143 }
24144 arg2 = static_cast< int >(val2);
24145 }
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24160 PyObject *resultobj = 0;
24161 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24162 bool arg2 ;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 bool val2 ;
24166 int ecode2 = 0 ;
24167 PyObject * obj0 = 0 ;
24168 PyObject * obj1 = 0 ;
24169 char * kwnames[] = {
24170 (char *) "self",(char *) "logOff", NULL
24171 };
24172
24173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24175 if (!SWIG_IsOK(res1)) {
24176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24177 }
24178 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24180 if (!SWIG_IsOK(ecode2)) {
24181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24182 }
24183 arg2 = static_cast< bool >(val2);
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 (arg1)->SetLoggingOff(arg2);
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_Py_Void();
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24198 PyObject *resultobj = 0;
24199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24200 bool result;
24201 void *argp1 = 0 ;
24202 int res1 = 0 ;
24203 PyObject *swig_obj[1] ;
24204
24205 if (!args) SWIG_fail;
24206 swig_obj[0] = args;
24207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24208 if (!SWIG_IsOK(res1)) {
24209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24210 }
24211 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 {
24219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24220 }
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24230 bool arg2 = (bool) true ;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 bool val2 ;
24234 int ecode2 = 0 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "self",(char *) "veto", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24245 }
24246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24247 if (obj1) {
24248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24249 if (!SWIG_IsOK(ecode2)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24251 }
24252 arg2 = static_cast< bool >(val2);
24253 }
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 (arg1)->Veto(arg2);
24257 wxPyEndAllowThreads(__tstate);
24258 if (PyErr_Occurred()) SWIG_fail;
24259 }
24260 resultobj = SWIG_Py_Void();
24261 return resultobj;
24262 fail:
24263 return NULL;
24264 }
24265
24266
24267 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24268 PyObject *resultobj = 0;
24269 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24270 bool result;
24271 void *argp1 = 0 ;
24272 int res1 = 0 ;
24273 PyObject *swig_obj[1] ;
24274
24275 if (!args) SWIG_fail;
24276 swig_obj[0] = args;
24277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24278 if (!SWIG_IsOK(res1)) {
24279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24280 }
24281 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 {
24289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24290 }
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj = 0;
24299 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24300 bool arg2 ;
24301 void *argp1 = 0 ;
24302 int res1 = 0 ;
24303 bool val2 ;
24304 int ecode2 = 0 ;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 char * kwnames[] = {
24308 (char *) "self",(char *) "canVeto", NULL
24309 };
24310
24311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24313 if (!SWIG_IsOK(res1)) {
24314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24315 }
24316 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24318 if (!SWIG_IsOK(ecode2)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24320 }
24321 arg2 = static_cast< bool >(val2);
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 (arg1)->SetCanVeto(arg2);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_Py_Void();
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24338 bool result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 PyObject *swig_obj[1] ;
24342
24343 if (!args) SWIG_fail;
24344 swig_obj[0] = args;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24348 }
24349 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 {
24357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24358 }
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *obj;
24367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24368 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24369 return SWIG_Py_Void();
24370 }
24371
24372 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24373 return SWIG_Python_InitShadowInstance(args);
24374 }
24375
24376 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24377 PyObject *resultobj = 0;
24378 int arg1 = (int) 0 ;
24379 bool arg2 = (bool) false ;
24380 wxShowEvent *result = 0 ;
24381 int val1 ;
24382 int ecode1 = 0 ;
24383 bool val2 ;
24384 int ecode2 = 0 ;
24385 PyObject * obj0 = 0 ;
24386 PyObject * obj1 = 0 ;
24387 char * kwnames[] = {
24388 (char *) "winid",(char *) "show", NULL
24389 };
24390
24391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24392 if (obj0) {
24393 ecode1 = SWIG_AsVal_int(obj0, &val1);
24394 if (!SWIG_IsOK(ecode1)) {
24395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24396 }
24397 arg1 = static_cast< int >(val1);
24398 }
24399 if (obj1) {
24400 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24401 if (!SWIG_IsOK(ecode2)) {
24402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24403 }
24404 arg2 = static_cast< bool >(val2);
24405 }
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24420 PyObject *resultobj = 0;
24421 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24422 bool arg2 ;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 bool val2 ;
24426 int ecode2 = 0 ;
24427 PyObject * obj0 = 0 ;
24428 PyObject * obj1 = 0 ;
24429 char * kwnames[] = {
24430 (char *) "self",(char *) "show", NULL
24431 };
24432
24433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24435 if (!SWIG_IsOK(res1)) {
24436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24437 }
24438 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24440 if (!SWIG_IsOK(ecode2)) {
24441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24442 }
24443 arg2 = static_cast< bool >(val2);
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 (arg1)->SetShow(arg2);
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 resultobj = SWIG_Py_Void();
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24458 PyObject *resultobj = 0;
24459 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24460 bool result;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 PyObject *swig_obj[1] ;
24464
24465 if (!args) SWIG_fail;
24466 swig_obj[0] = args;
24467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24468 if (!SWIG_IsOK(res1)) {
24469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24470 }
24471 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24472 {
24473 PyThreadState* __tstate = wxPyBeginAllowThreads();
24474 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 {
24479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24480 }
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24488 PyObject *obj;
24489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24490 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24491 return SWIG_Py_Void();
24492 }
24493
24494 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24495 return SWIG_Python_InitShadowInstance(args);
24496 }
24497
24498 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj = 0;
24500 int arg1 = (int) 0 ;
24501 bool arg2 = (bool) true ;
24502 wxIconizeEvent *result = 0 ;
24503 int val1 ;
24504 int ecode1 = 0 ;
24505 bool val2 ;
24506 int ecode2 = 0 ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char * kwnames[] = {
24510 (char *) "id",(char *) "iconized", NULL
24511 };
24512
24513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24514 if (obj0) {
24515 ecode1 = SWIG_AsVal_int(obj0, &val1);
24516 if (!SWIG_IsOK(ecode1)) {
24517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24518 }
24519 arg1 = static_cast< int >(val1);
24520 }
24521 if (obj1) {
24522 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24523 if (!SWIG_IsOK(ecode2)) {
24524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24525 }
24526 arg2 = static_cast< bool >(val2);
24527 }
24528 {
24529 PyThreadState* __tstate = wxPyBeginAllowThreads();
24530 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24531 wxPyEndAllowThreads(__tstate);
24532 if (PyErr_Occurred()) SWIG_fail;
24533 }
24534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 PyObject *resultobj = 0;
24543 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24544 bool result;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 PyObject *swig_obj[1] ;
24548
24549 if (!args) SWIG_fail;
24550 swig_obj[0] = args;
24551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24552 if (!SWIG_IsOK(res1)) {
24553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24554 }
24555 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = (bool)(arg1)->Iconized();
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24564 }
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 PyObject *obj;
24573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24574 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24575 return SWIG_Py_Void();
24576 }
24577
24578 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24579 return SWIG_Python_InitShadowInstance(args);
24580 }
24581
24582 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24583 PyObject *resultobj = 0;
24584 int arg1 = (int) 0 ;
24585 wxMaximizeEvent *result = 0 ;
24586 int val1 ;
24587 int ecode1 = 0 ;
24588 PyObject * obj0 = 0 ;
24589 char * kwnames[] = {
24590 (char *) "id", NULL
24591 };
24592
24593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24594 if (obj0) {
24595 ecode1 = SWIG_AsVal_int(obj0, &val1);
24596 if (!SWIG_IsOK(ecode1)) {
24597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24598 }
24599 arg1 = static_cast< int >(val1);
24600 }
24601 {
24602 PyThreadState* __tstate = wxPyBeginAllowThreads();
24603 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *obj;
24616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24617 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24618 return SWIG_Py_Void();
24619 }
24620
24621 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 return SWIG_Python_InitShadowInstance(args);
24623 }
24624
24625 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24626 PyObject *resultobj = 0;
24627 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24628 wxPoint result;
24629 void *argp1 = 0 ;
24630 int res1 = 0 ;
24631 PyObject *swig_obj[1] ;
24632
24633 if (!args) SWIG_fail;
24634 swig_obj[0] = args;
24635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24636 if (!SWIG_IsOK(res1)) {
24637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24638 }
24639 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 result = (arg1)->GetPosition();
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24647 return resultobj;
24648 fail:
24649 return NULL;
24650 }
24651
24652
24653 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24654 PyObject *resultobj = 0;
24655 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24656 int result;
24657 void *argp1 = 0 ;
24658 int res1 = 0 ;
24659 PyObject *swig_obj[1] ;
24660
24661 if (!args) SWIG_fail;
24662 swig_obj[0] = args;
24663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24664 if (!SWIG_IsOK(res1)) {
24665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24666 }
24667 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (int)(arg1)->GetNumberOfFiles();
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_From_int(static_cast< int >(result));
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *resultobj = 0;
24683 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24684 PyObject *result = 0 ;
24685 void *argp1 = 0 ;
24686 int res1 = 0 ;
24687 PyObject *swig_obj[1] ;
24688
24689 if (!args) SWIG_fail;
24690 swig_obj[0] = args;
24691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24692 if (!SWIG_IsOK(res1)) {
24693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24694 }
24695 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = result;
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *obj;
24711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24712 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24713 return SWIG_Py_Void();
24714 }
24715
24716 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24717 PyObject *resultobj = 0;
24718 int arg1 = (int) 0 ;
24719 wxUpdateUIEvent *result = 0 ;
24720 int val1 ;
24721 int ecode1 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 char * kwnames[] = {
24724 (char *) "commandId", NULL
24725 };
24726
24727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24728 if (obj0) {
24729 ecode1 = SWIG_AsVal_int(obj0, &val1);
24730 if (!SWIG_IsOK(ecode1)) {
24731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24732 }
24733 arg1 = static_cast< int >(val1);
24734 }
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24751 bool result;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 PyObject *swig_obj[1] ;
24755
24756 if (!args) SWIG_fail;
24757 swig_obj[0] = args;
24758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24761 }
24762 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 {
24770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24771 }
24772 return resultobj;
24773 fail:
24774 return NULL;
24775 }
24776
24777
24778 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24779 PyObject *resultobj = 0;
24780 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24781 bool result;
24782 void *argp1 = 0 ;
24783 int res1 = 0 ;
24784 PyObject *swig_obj[1] ;
24785
24786 if (!args) SWIG_fail;
24787 swig_obj[0] = args;
24788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24789 if (!SWIG_IsOK(res1)) {
24790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24791 }
24792 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24796 wxPyEndAllowThreads(__tstate);
24797 if (PyErr_Occurred()) SWIG_fail;
24798 }
24799 {
24800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24801 }
24802 return resultobj;
24803 fail:
24804 return NULL;
24805 }
24806
24807
24808 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24809 PyObject *resultobj = 0;
24810 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24811 bool result;
24812 void *argp1 = 0 ;
24813 int res1 = 0 ;
24814 PyObject *swig_obj[1] ;
24815
24816 if (!args) SWIG_fail;
24817 swig_obj[0] = args;
24818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24819 if (!SWIG_IsOK(res1)) {
24820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24821 }
24822 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 {
24830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24831 }
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24839 PyObject *resultobj = 0;
24840 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24841 wxString result;
24842 void *argp1 = 0 ;
24843 int res1 = 0 ;
24844 PyObject *swig_obj[1] ;
24845
24846 if (!args) SWIG_fail;
24847 swig_obj[0] = args;
24848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24851 }
24852 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24853 {
24854 PyThreadState* __tstate = wxPyBeginAllowThreads();
24855 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24856 wxPyEndAllowThreads(__tstate);
24857 if (PyErr_Occurred()) SWIG_fail;
24858 }
24859 {
24860 #if wxUSE_UNICODE
24861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24862 #else
24863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24864 #endif
24865 }
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24875 bool result;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24885 }
24886 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *resultobj = 0;
24904 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24905 bool result;
24906 void *argp1 = 0 ;
24907 int res1 = 0 ;
24908 PyObject *swig_obj[1] ;
24909
24910 if (!args) SWIG_fail;
24911 swig_obj[0] = args;
24912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24915 }
24916 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 {
24924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24925 }
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24933 PyObject *resultobj = 0;
24934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24935 bool result;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 PyObject *swig_obj[1] ;
24939
24940 if (!args) SWIG_fail;
24941 swig_obj[0] = args;
24942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24943 if (!SWIG_IsOK(res1)) {
24944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24945 }
24946 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24963 PyObject *resultobj = 0;
24964 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24965 bool result;
24966 void *argp1 = 0 ;
24967 int res1 = 0 ;
24968 PyObject *swig_obj[1] ;
24969
24970 if (!args) SWIG_fail;
24971 swig_obj[0] = args;
24972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24973 if (!SWIG_IsOK(res1)) {
24974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24975 }
24976 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 {
24984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24985 }
24986 return resultobj;
24987 fail:
24988 return NULL;
24989 }
24990
24991
24992 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24993 PyObject *resultobj = 0;
24994 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24995 bool arg2 ;
24996 void *argp1 = 0 ;
24997 int res1 = 0 ;
24998 bool val2 ;
24999 int ecode2 = 0 ;
25000 PyObject * obj0 = 0 ;
25001 PyObject * obj1 = 0 ;
25002 char * kwnames[] = {
25003 (char *) "self",(char *) "check", NULL
25004 };
25005
25006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25008 if (!SWIG_IsOK(res1)) {
25009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25010 }
25011 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25012 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25013 if (!SWIG_IsOK(ecode2)) {
25014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25015 }
25016 arg2 = static_cast< bool >(val2);
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 (arg1)->Check(arg2);
25020 wxPyEndAllowThreads(__tstate);
25021 if (PyErr_Occurred()) SWIG_fail;
25022 }
25023 resultobj = SWIG_Py_Void();
25024 return resultobj;
25025 fail:
25026 return NULL;
25027 }
25028
25029
25030 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25031 PyObject *resultobj = 0;
25032 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25033 bool arg2 ;
25034 void *argp1 = 0 ;
25035 int res1 = 0 ;
25036 bool val2 ;
25037 int ecode2 = 0 ;
25038 PyObject * obj0 = 0 ;
25039 PyObject * obj1 = 0 ;
25040 char * kwnames[] = {
25041 (char *) "self",(char *) "enable", NULL
25042 };
25043
25044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25046 if (!SWIG_IsOK(res1)) {
25047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25048 }
25049 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25051 if (!SWIG_IsOK(ecode2)) {
25052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25053 }
25054 arg2 = static_cast< bool >(val2);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 (arg1)->Enable(arg2);
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 resultobj = SWIG_Py_Void();
25062 return resultobj;
25063 fail:
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25071 bool arg2 ;
25072 void *argp1 = 0 ;
25073 int res1 = 0 ;
25074 bool val2 ;
25075 int ecode2 = 0 ;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 char * kwnames[] = {
25079 (char *) "self",(char *) "show", NULL
25080 };
25081
25082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25084 if (!SWIG_IsOK(res1)) {
25085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25086 }
25087 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25089 if (!SWIG_IsOK(ecode2)) {
25090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25091 }
25092 arg2 = static_cast< bool >(val2);
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 (arg1)->Show(arg2);
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 resultobj = SWIG_Py_Void();
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj = 0;
25108 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25109 wxString *arg2 = 0 ;
25110 void *argp1 = 0 ;
25111 int res1 = 0 ;
25112 bool temp2 = false ;
25113 PyObject * obj0 = 0 ;
25114 PyObject * obj1 = 0 ;
25115 char * kwnames[] = {
25116 (char *) "self",(char *) "text", NULL
25117 };
25118
25119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25121 if (!SWIG_IsOK(res1)) {
25122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25123 }
25124 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25125 {
25126 arg2 = wxString_in_helper(obj1);
25127 if (arg2 == NULL) SWIG_fail;
25128 temp2 = true;
25129 }
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 (arg1)->SetText((wxString const &)*arg2);
25133 wxPyEndAllowThreads(__tstate);
25134 if (PyErr_Occurred()) SWIG_fail;
25135 }
25136 resultobj = SWIG_Py_Void();
25137 {
25138 if (temp2)
25139 delete arg2;
25140 }
25141 return resultobj;
25142 fail:
25143 {
25144 if (temp2)
25145 delete arg2;
25146 }
25147 return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25152 PyObject *resultobj = 0;
25153 long arg1 ;
25154 long val1 ;
25155 int ecode1 = 0 ;
25156 PyObject * obj0 = 0 ;
25157 char * kwnames[] = {
25158 (char *) "updateInterval", NULL
25159 };
25160
25161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25162 ecode1 = SWIG_AsVal_long(obj0, &val1);
25163 if (!SWIG_IsOK(ecode1)) {
25164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25165 }
25166 arg1 = static_cast< long >(val1);
25167 {
25168 PyThreadState* __tstate = wxPyBeginAllowThreads();
25169 wxUpdateUIEvent::SetUpdateInterval(arg1);
25170 wxPyEndAllowThreads(__tstate);
25171 if (PyErr_Occurred()) SWIG_fail;
25172 }
25173 resultobj = SWIG_Py_Void();
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25181 PyObject *resultobj = 0;
25182 long result;
25183
25184 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 resultobj = SWIG_From_long(static_cast< long >(result));
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = 0;
25200 wxWindow *arg1 = (wxWindow *) 0 ;
25201 bool result;
25202 void *argp1 = 0 ;
25203 int res1 = 0 ;
25204 PyObject * obj0 = 0 ;
25205 char * kwnames[] = {
25206 (char *) "win", NULL
25207 };
25208
25209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25211 if (!SWIG_IsOK(res1)) {
25212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25213 }
25214 arg1 = reinterpret_cast< wxWindow * >(argp1);
25215 {
25216 PyThreadState* __tstate = wxPyBeginAllowThreads();
25217 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 {
25222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25223 }
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25231 PyObject *resultobj = 0;
25232
25233 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxUpdateUIEvent::ResetUpdateTime();
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj = 0;
25249 wxUpdateUIMode arg1 ;
25250 int val1 ;
25251 int ecode1 = 0 ;
25252 PyObject * obj0 = 0 ;
25253 char * kwnames[] = {
25254 (char *) "mode", NULL
25255 };
25256
25257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25258 ecode1 = SWIG_AsVal_int(obj0, &val1);
25259 if (!SWIG_IsOK(ecode1)) {
25260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25261 }
25262 arg1 = static_cast< wxUpdateUIMode >(val1);
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 wxUpdateUIEvent::SetMode(arg1);
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 resultobj = SWIG_Py_Void();
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 PyObject *resultobj = 0;
25278 wxUpdateUIMode result;
25279
25280 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_From_int(static_cast< int >(result));
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *obj;
25296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25297 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25298 return SWIG_Py_Void();
25299 }
25300
25301 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25302 return SWIG_Python_InitShadowInstance(args);
25303 }
25304
25305 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25306 PyObject *resultobj = 0;
25307 wxSysColourChangedEvent *result = 0 ;
25308
25309 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *obj;
25325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25326 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25327 return SWIG_Py_Void();
25328 }
25329
25330 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25331 return SWIG_Python_InitShadowInstance(args);
25332 }
25333
25334 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 int arg1 = (int) 0 ;
25337 wxWindow *arg2 = (wxWindow *) NULL ;
25338 wxMouseCaptureChangedEvent *result = 0 ;
25339 int val1 ;
25340 int ecode1 = 0 ;
25341 void *argp2 = 0 ;
25342 int res2 = 0 ;
25343 PyObject * obj0 = 0 ;
25344 PyObject * obj1 = 0 ;
25345 char * kwnames[] = {
25346 (char *) "winid",(char *) "gainedCapture", NULL
25347 };
25348
25349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25350 if (obj0) {
25351 ecode1 = SWIG_AsVal_int(obj0, &val1);
25352 if (!SWIG_IsOK(ecode1)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25354 }
25355 arg1 = static_cast< int >(val1);
25356 }
25357 if (obj1) {
25358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25359 if (!SWIG_IsOK(res2)) {
25360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25361 }
25362 arg2 = reinterpret_cast< wxWindow * >(argp2);
25363 }
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25367 wxPyEndAllowThreads(__tstate);
25368 if (PyErr_Occurred()) SWIG_fail;
25369 }
25370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25371 return resultobj;
25372 fail:
25373 return NULL;
25374 }
25375
25376
25377 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25378 PyObject *resultobj = 0;
25379 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25380 wxWindow *result = 0 ;
25381 void *argp1 = 0 ;
25382 int res1 = 0 ;
25383 PyObject *swig_obj[1] ;
25384
25385 if (!args) SWIG_fail;
25386 swig_obj[0] = args;
25387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25388 if (!SWIG_IsOK(res1)) {
25389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25390 }
25391 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25392 {
25393 PyThreadState* __tstate = wxPyBeginAllowThreads();
25394 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25395 wxPyEndAllowThreads(__tstate);
25396 if (PyErr_Occurred()) SWIG_fail;
25397 }
25398 {
25399 resultobj = wxPyMake_wxObject(result, (bool)0);
25400 }
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25408 PyObject *obj;
25409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25410 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25411 return SWIG_Py_Void();
25412 }
25413
25414 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25415 return SWIG_Python_InitShadowInstance(args);
25416 }
25417
25418 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxDisplayChangedEvent *result = 0 ;
25421
25422 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25437 PyObject *obj;
25438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25439 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25440 return SWIG_Py_Void();
25441 }
25442
25443 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25444 return SWIG_Python_InitShadowInstance(args);
25445 }
25446
25447 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25448 PyObject *resultobj = 0;
25449 int arg1 = (int) 0 ;
25450 wxPaletteChangedEvent *result = 0 ;
25451 int val1 ;
25452 int ecode1 = 0 ;
25453 PyObject * obj0 = 0 ;
25454 char * kwnames[] = {
25455 (char *) "id", NULL
25456 };
25457
25458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25459 if (obj0) {
25460 ecode1 = SWIG_AsVal_int(obj0, &val1);
25461 if (!SWIG_IsOK(ecode1)) {
25462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25463 }
25464 arg1 = static_cast< int >(val1);
25465 }
25466 {
25467 PyThreadState* __tstate = wxPyBeginAllowThreads();
25468 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25469 wxPyEndAllowThreads(__tstate);
25470 if (PyErr_Occurred()) SWIG_fail;
25471 }
25472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj = 0;
25481 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25482 wxWindow *arg2 = (wxWindow *) 0 ;
25483 void *argp1 = 0 ;
25484 int res1 = 0 ;
25485 void *argp2 = 0 ;
25486 int res2 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 char * kwnames[] = {
25490 (char *) "self",(char *) "win", NULL
25491 };
25492
25493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25495 if (!SWIG_IsOK(res1)) {
25496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25497 }
25498 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25500 if (!SWIG_IsOK(res2)) {
25501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25502 }
25503 arg2 = reinterpret_cast< wxWindow * >(argp2);
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 (arg1)->SetChangedWindow(arg2);
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 resultobj = SWIG_Py_Void();
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *resultobj = 0;
25519 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25520 wxWindow *result = 0 ;
25521 void *argp1 = 0 ;
25522 int res1 = 0 ;
25523 PyObject *swig_obj[1] ;
25524
25525 if (!args) SWIG_fail;
25526 swig_obj[0] = args;
25527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25528 if (!SWIG_IsOK(res1)) {
25529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25530 }
25531 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 result = (wxWindow *)(arg1)->GetChangedWindow();
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 {
25539 resultobj = wxPyMake_wxObject(result, (bool)0);
25540 }
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25548 PyObject *obj;
25549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25551 return SWIG_Py_Void();
25552 }
25553
25554 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 return SWIG_Python_InitShadowInstance(args);
25556 }
25557
25558 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj = 0;
25560 int arg1 = (int) 0 ;
25561 wxQueryNewPaletteEvent *result = 0 ;
25562 int val1 ;
25563 int ecode1 = 0 ;
25564 PyObject * obj0 = 0 ;
25565 char * kwnames[] = {
25566 (char *) "winid", NULL
25567 };
25568
25569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25570 if (obj0) {
25571 ecode1 = SWIG_AsVal_int(obj0, &val1);
25572 if (!SWIG_IsOK(ecode1)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25574 }
25575 arg1 = static_cast< int >(val1);
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25593 bool arg2 ;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 bool val2 ;
25597 int ecode2 = 0 ;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 char * kwnames[] = {
25601 (char *) "self",(char *) "realized", NULL
25602 };
25603
25604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25610 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25611 if (!SWIG_IsOK(ecode2)) {
25612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25613 }
25614 arg2 = static_cast< bool >(val2);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 (arg1)->SetPaletteRealized(arg2);
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_Py_Void();
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25631 bool result;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25641 }
25642 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 {
25650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25651 }
25652 return resultobj;
25653 fail:
25654 return NULL;
25655 }
25656
25657
25658 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25659 PyObject *obj;
25660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25661 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25662 return SWIG_Py_Void();
25663 }
25664
25665 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 return SWIG_Python_InitShadowInstance(args);
25667 }
25668
25669 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 PyObject *resultobj = 0;
25671 wxNavigationKeyEvent *result = 0 ;
25672
25673 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25688 PyObject *resultobj = 0;
25689 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25690 bool result;
25691 void *argp1 = 0 ;
25692 int res1 = 0 ;
25693 PyObject *swig_obj[1] ;
25694
25695 if (!args) SWIG_fail;
25696 swig_obj[0] = args;
25697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25698 if (!SWIG_IsOK(res1)) {
25699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25700 }
25701 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 {
25709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25710 }
25711 return resultobj;
25712 fail:
25713 return NULL;
25714 }
25715
25716
25717 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25718 PyObject *resultobj = 0;
25719 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25720 bool arg2 ;
25721 void *argp1 = 0 ;
25722 int res1 = 0 ;
25723 bool val2 ;
25724 int ecode2 = 0 ;
25725 PyObject * obj0 = 0 ;
25726 PyObject * obj1 = 0 ;
25727 char * kwnames[] = {
25728 (char *) "self",(char *) "forward", NULL
25729 };
25730
25731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25733 if (!SWIG_IsOK(res1)) {
25734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25735 }
25736 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25737 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25738 if (!SWIG_IsOK(ecode2)) {
25739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25740 }
25741 arg2 = static_cast< bool >(val2);
25742 {
25743 PyThreadState* __tstate = wxPyBeginAllowThreads();
25744 (arg1)->SetDirection(arg2);
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 resultobj = SWIG_Py_Void();
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25756 PyObject *resultobj = 0;
25757 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25758 bool result;
25759 void *argp1 = 0 ;
25760 int res1 = 0 ;
25761 PyObject *swig_obj[1] ;
25762
25763 if (!args) SWIG_fail;
25764 swig_obj[0] = args;
25765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25766 if (!SWIG_IsOK(res1)) {
25767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25768 }
25769 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25773 wxPyEndAllowThreads(__tstate);
25774 if (PyErr_Occurred()) SWIG_fail;
25775 }
25776 {
25777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25778 }
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25786 PyObject *resultobj = 0;
25787 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25788 bool arg2 ;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 bool val2 ;
25792 int ecode2 = 0 ;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 char * kwnames[] = {
25796 (char *) "self",(char *) "ischange", NULL
25797 };
25798
25799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25801 if (!SWIG_IsOK(res1)) {
25802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25803 }
25804 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25806 if (!SWIG_IsOK(ecode2)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25808 }
25809 arg2 = static_cast< bool >(val2);
25810 {
25811 PyThreadState* __tstate = wxPyBeginAllowThreads();
25812 (arg1)->SetWindowChange(arg2);
25813 wxPyEndAllowThreads(__tstate);
25814 if (PyErr_Occurred()) SWIG_fail;
25815 }
25816 resultobj = SWIG_Py_Void();
25817 return resultobj;
25818 fail:
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25824 PyObject *resultobj = 0;
25825 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25826 bool result;
25827 void *argp1 = 0 ;
25828 int res1 = 0 ;
25829 PyObject *swig_obj[1] ;
25830
25831 if (!args) SWIG_fail;
25832 swig_obj[0] = args;
25833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25836 }
25837 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 {
25845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25846 }
25847 return resultobj;
25848 fail:
25849 return NULL;
25850 }
25851
25852
25853 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25854 PyObject *resultobj = 0;
25855 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25856 bool arg2 ;
25857 void *argp1 = 0 ;
25858 int res1 = 0 ;
25859 bool val2 ;
25860 int ecode2 = 0 ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 char * kwnames[] = {
25864 (char *) "self",(char *) "bIs", NULL
25865 };
25866
25867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25869 if (!SWIG_IsOK(res1)) {
25870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25871 }
25872 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25874 if (!SWIG_IsOK(ecode2)) {
25875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25876 }
25877 arg2 = static_cast< bool >(val2);
25878 {
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 (arg1)->SetFromTab(arg2);
25881 wxPyEndAllowThreads(__tstate);
25882 if (PyErr_Occurred()) SWIG_fail;
25883 }
25884 resultobj = SWIG_Py_Void();
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj = 0;
25893 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25894 long arg2 ;
25895 void *argp1 = 0 ;
25896 int res1 = 0 ;
25897 long val2 ;
25898 int ecode2 = 0 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 char * kwnames[] = {
25902 (char *) "self",(char *) "flags", NULL
25903 };
25904
25905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25907 if (!SWIG_IsOK(res1)) {
25908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25909 }
25910 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25911 ecode2 = SWIG_AsVal_long(obj1, &val2);
25912 if (!SWIG_IsOK(ecode2)) {
25913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25914 }
25915 arg2 = static_cast< long >(val2);
25916 {
25917 PyThreadState* __tstate = wxPyBeginAllowThreads();
25918 (arg1)->SetFlags(arg2);
25919 wxPyEndAllowThreads(__tstate);
25920 if (PyErr_Occurred()) SWIG_fail;
25921 }
25922 resultobj = SWIG_Py_Void();
25923 return resultobj;
25924 fail:
25925 return NULL;
25926 }
25927
25928
25929 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25930 PyObject *resultobj = 0;
25931 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25932 wxWindow *result = 0 ;
25933 void *argp1 = 0 ;
25934 int res1 = 0 ;
25935 PyObject *swig_obj[1] ;
25936
25937 if (!args) SWIG_fail;
25938 swig_obj[0] = args;
25939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25942 }
25943 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 {
25951 resultobj = wxPyMake_wxObject(result, (bool)0);
25952 }
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25960 PyObject *resultobj = 0;
25961 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25962 wxWindow *arg2 = (wxWindow *) 0 ;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 void *argp2 = 0 ;
25966 int res2 = 0 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char * kwnames[] = {
25970 (char *) "self",(char *) "win", NULL
25971 };
25972
25973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25975 if (!SWIG_IsOK(res1)) {
25976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25977 }
25978 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25980 if (!SWIG_IsOK(res2)) {
25981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25982 }
25983 arg2 = reinterpret_cast< wxWindow * >(argp2);
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->SetCurrentFocus(arg2);
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_Py_Void();
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 PyObject *obj;
25999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26000 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26001 return SWIG_Py_Void();
26002 }
26003
26004 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26005 return SWIG_Python_InitShadowInstance(args);
26006 }
26007
26008 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj = 0;
26010 wxWindow *arg1 = (wxWindow *) NULL ;
26011 wxWindowCreateEvent *result = 0 ;
26012 void *argp1 = 0 ;
26013 int res1 = 0 ;
26014 PyObject * obj0 = 0 ;
26015 char * kwnames[] = {
26016 (char *) "win", NULL
26017 };
26018
26019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26020 if (obj0) {
26021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26022 if (!SWIG_IsOK(res1)) {
26023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26024 }
26025 arg1 = reinterpret_cast< wxWindow * >(argp1);
26026 }
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26043 wxWindow *result = 0 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 PyObject *swig_obj[1] ;
26047
26048 if (!args) SWIG_fail;
26049 swig_obj[0] = args;
26050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26053 }
26054 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 {
26062 resultobj = wxPyMake_wxObject(result, (bool)0);
26063 }
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 PyObject *obj;
26072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26073 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26074 return SWIG_Py_Void();
26075 }
26076
26077 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26078 return SWIG_Python_InitShadowInstance(args);
26079 }
26080
26081 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26082 PyObject *resultobj = 0;
26083 wxWindow *arg1 = (wxWindow *) NULL ;
26084 wxWindowDestroyEvent *result = 0 ;
26085 void *argp1 = 0 ;
26086 int res1 = 0 ;
26087 PyObject * obj0 = 0 ;
26088 char * kwnames[] = {
26089 (char *) "win", NULL
26090 };
26091
26092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26093 if (obj0) {
26094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26095 if (!SWIG_IsOK(res1)) {
26096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26097 }
26098 arg1 = reinterpret_cast< wxWindow * >(argp1);
26099 }
26100 {
26101 PyThreadState* __tstate = wxPyBeginAllowThreads();
26102 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26103 wxPyEndAllowThreads(__tstate);
26104 if (PyErr_Occurred()) SWIG_fail;
26105 }
26106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26114 PyObject *resultobj = 0;
26115 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26116 wxWindow *result = 0 ;
26117 void *argp1 = 0 ;
26118 int res1 = 0 ;
26119 PyObject *swig_obj[1] ;
26120
26121 if (!args) SWIG_fail;
26122 swig_obj[0] = args;
26123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26124 if (!SWIG_IsOK(res1)) {
26125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26126 }
26127 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 {
26135 resultobj = wxPyMake_wxObject(result, (bool)0);
26136 }
26137 return resultobj;
26138 fail:
26139 return NULL;
26140 }
26141
26142
26143 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26144 PyObject *obj;
26145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26146 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26147 return SWIG_Py_Void();
26148 }
26149
26150 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26151 return SWIG_Python_InitShadowInstance(args);
26152 }
26153
26154 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj = 0;
26156 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26157 int arg2 = (int) 0 ;
26158 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26159 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26160 wxContextMenuEvent *result = 0 ;
26161 int val1 ;
26162 int ecode1 = 0 ;
26163 int val2 ;
26164 int ecode2 = 0 ;
26165 wxPoint temp3 ;
26166 PyObject * obj0 = 0 ;
26167 PyObject * obj1 = 0 ;
26168 PyObject * obj2 = 0 ;
26169 char * kwnames[] = {
26170 (char *) "type",(char *) "winid",(char *) "pt", NULL
26171 };
26172
26173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26174 if (obj0) {
26175 ecode1 = SWIG_AsVal_int(obj0, &val1);
26176 if (!SWIG_IsOK(ecode1)) {
26177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26178 }
26179 arg1 = static_cast< wxEventType >(val1);
26180 }
26181 if (obj1) {
26182 ecode2 = SWIG_AsVal_int(obj1, &val2);
26183 if (!SWIG_IsOK(ecode2)) {
26184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26185 }
26186 arg2 = static_cast< int >(val2);
26187 }
26188 if (obj2) {
26189 {
26190 arg3 = &temp3;
26191 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26192 }
26193 }
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26208 PyObject *resultobj = 0;
26209 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26210 wxPoint *result = 0 ;
26211 void *argp1 = 0 ;
26212 int res1 = 0 ;
26213 PyObject *swig_obj[1] ;
26214
26215 if (!args) SWIG_fail;
26216 swig_obj[0] = args;
26217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26218 if (!SWIG_IsOK(res1)) {
26219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26220 }
26221 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 {
26225 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26226 result = (wxPoint *) &_result_ref;
26227 }
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj = 0;
26240 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26241 wxPoint *arg2 = 0 ;
26242 void *argp1 = 0 ;
26243 int res1 = 0 ;
26244 wxPoint temp2 ;
26245 PyObject * obj0 = 0 ;
26246 PyObject * obj1 = 0 ;
26247 char * kwnames[] = {
26248 (char *) "self",(char *) "pos", NULL
26249 };
26250
26251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26255 }
26256 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26257 {
26258 arg2 = &temp2;
26259 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 (arg1)->SetPosition((wxPoint const &)*arg2);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 resultobj = SWIG_Py_Void();
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *ContextMenuEvent_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_wxContextMenuEvent, SWIG_NewClientData(obj));
26278 return SWIG_Py_Void();
26279 }
26280
26281 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 return SWIG_Python_InitShadowInstance(args);
26283 }
26284
26285 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 PyObject *resultobj = 0;
26287 wxIdleEvent *result = 0 ;
26288
26289 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 result = (wxIdleEvent *)new wxIdleEvent();
26293 wxPyEndAllowThreads(__tstate);
26294 if (PyErr_Occurred()) SWIG_fail;
26295 }
26296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26297 return resultobj;
26298 fail:
26299 return NULL;
26300 }
26301
26302
26303 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26304 PyObject *resultobj = 0;
26305 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26306 bool arg2 = (bool) true ;
26307 void *argp1 = 0 ;
26308 int res1 = 0 ;
26309 bool val2 ;
26310 int ecode2 = 0 ;
26311 PyObject * obj0 = 0 ;
26312 PyObject * obj1 = 0 ;
26313 char * kwnames[] = {
26314 (char *) "self",(char *) "needMore", NULL
26315 };
26316
26317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26319 if (!SWIG_IsOK(res1)) {
26320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26321 }
26322 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26323 if (obj1) {
26324 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26325 if (!SWIG_IsOK(ecode2)) {
26326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26327 }
26328 arg2 = static_cast< bool >(val2);
26329 }
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 (arg1)->RequestMore(arg2);
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 resultobj = SWIG_Py_Void();
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26344 PyObject *resultobj = 0;
26345 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26346 bool result;
26347 void *argp1 = 0 ;
26348 int res1 = 0 ;
26349 PyObject *swig_obj[1] ;
26350
26351 if (!args) SWIG_fail;
26352 swig_obj[0] = args;
26353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26354 if (!SWIG_IsOK(res1)) {
26355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26356 }
26357 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26358 {
26359 PyThreadState* __tstate = wxPyBeginAllowThreads();
26360 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26361 wxPyEndAllowThreads(__tstate);
26362 if (PyErr_Occurred()) SWIG_fail;
26363 }
26364 {
26365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26366 }
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxIdleMode arg1 ;
26376 int val1 ;
26377 int ecode1 = 0 ;
26378 PyObject * obj0 = 0 ;
26379 char * kwnames[] = {
26380 (char *) "mode", NULL
26381 };
26382
26383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26384 ecode1 = SWIG_AsVal_int(obj0, &val1);
26385 if (!SWIG_IsOK(ecode1)) {
26386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26387 }
26388 arg1 = static_cast< wxIdleMode >(val1);
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 wxIdleEvent::SetMode(arg1);
26392 wxPyEndAllowThreads(__tstate);
26393 if (PyErr_Occurred()) SWIG_fail;
26394 }
26395 resultobj = SWIG_Py_Void();
26396 return resultobj;
26397 fail:
26398 return NULL;
26399 }
26400
26401
26402 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26403 PyObject *resultobj = 0;
26404 wxIdleMode result;
26405
26406 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxIdleMode)wxIdleEvent::GetMode();
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_From_int(static_cast< int >(result));
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj = 0;
26422 wxWindow *arg1 = (wxWindow *) 0 ;
26423 bool result;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 PyObject * obj0 = 0 ;
26427 char * kwnames[] = {
26428 (char *) "win", NULL
26429 };
26430
26431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26435 }
26436 arg1 = reinterpret_cast< wxWindow * >(argp1);
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = (bool)wxIdleEvent::CanSend(arg1);
26440 wxPyEndAllowThreads(__tstate);
26441 if (PyErr_Occurred()) SWIG_fail;
26442 }
26443 {
26444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26445 }
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26453 PyObject *obj;
26454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26455 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26456 return SWIG_Py_Void();
26457 }
26458
26459 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26460 return SWIG_Python_InitShadowInstance(args);
26461 }
26462
26463 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj = 0;
26465 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26466 int arg2 = (int) 0 ;
26467 wxClipboardTextEvent *result = 0 ;
26468 int val1 ;
26469 int ecode1 = 0 ;
26470 int val2 ;
26471 int ecode2 = 0 ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "type",(char *) "winid", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26479 if (obj0) {
26480 ecode1 = SWIG_AsVal_int(obj0, &val1);
26481 if (!SWIG_IsOK(ecode1)) {
26482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26483 }
26484 arg1 = static_cast< wxEventType >(val1);
26485 }
26486 if (obj1) {
26487 ecode2 = SWIG_AsVal_int(obj1, &val2);
26488 if (!SWIG_IsOK(ecode2)) {
26489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26490 }
26491 arg2 = static_cast< int >(val2);
26492 }
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *obj;
26508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26509 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26510 return SWIG_Py_Void();
26511 }
26512
26513 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 return SWIG_Python_InitShadowInstance(args);
26515 }
26516
26517 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj = 0;
26519 int arg1 = (int) 0 ;
26520 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26521 wxPyEvent *result = 0 ;
26522 int val1 ;
26523 int ecode1 = 0 ;
26524 int val2 ;
26525 int ecode2 = 0 ;
26526 PyObject * obj0 = 0 ;
26527 PyObject * obj1 = 0 ;
26528 char * kwnames[] = {
26529 (char *) "winid",(char *) "eventType", NULL
26530 };
26531
26532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26533 if (obj0) {
26534 ecode1 = SWIG_AsVal_int(obj0, &val1);
26535 if (!SWIG_IsOK(ecode1)) {
26536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26537 }
26538 arg1 = static_cast< int >(val1);
26539 }
26540 if (obj1) {
26541 ecode2 = SWIG_AsVal_int(obj1, &val2);
26542 if (!SWIG_IsOK(ecode2)) {
26543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26544 }
26545 arg2 = static_cast< wxEventType >(val2);
26546 }
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26561 PyObject *resultobj = 0;
26562 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26563 void *argp1 = 0 ;
26564 int res1 = 0 ;
26565 PyObject *swig_obj[1] ;
26566
26567 if (!args) SWIG_fail;
26568 swig_obj[0] = args;
26569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26570 if (!SWIG_IsOK(res1)) {
26571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26572 }
26573 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 delete arg1;
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 resultobj = SWIG_Py_Void();
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj = 0;
26590 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26591 PyObject *arg2 = (PyObject *) 0 ;
26592 void *argp1 = 0 ;
26593 int res1 = 0 ;
26594 PyObject * obj0 = 0 ;
26595 PyObject * obj1 = 0 ;
26596 char * kwnames[] = {
26597 (char *) "self",(char *) "self", NULL
26598 };
26599
26600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26602 if (!SWIG_IsOK(res1)) {
26603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26604 }
26605 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26606 arg2 = obj1;
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 (arg1)->SetSelf(arg2);
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_Py_Void();
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26621 PyObject *resultobj = 0;
26622 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26623 PyObject *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_wxPyEvent, 0 | 0 );
26631 if (!SWIG_IsOK(res1)) {
26632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26633 }
26634 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (PyObject *)(arg1)->GetSelf();
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 resultobj = result;
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *obj;
26650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26651 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26652 return SWIG_Py_Void();
26653 }
26654
26655 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 return SWIG_Python_InitShadowInstance(args);
26657 }
26658
26659 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26662 int arg2 = (int) 0 ;
26663 wxPyCommandEvent *result = 0 ;
26664 int val1 ;
26665 int ecode1 = 0 ;
26666 int val2 ;
26667 int ecode2 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "eventType",(char *) "id", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26675 if (obj0) {
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26679 }
26680 arg1 = static_cast< wxEventType >(val1);
26681 }
26682 if (obj1) {
26683 ecode2 = SWIG_AsVal_int(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26686 }
26687 arg2 = static_cast< int >(val2);
26688 }
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 PyObject *resultobj = 0;
26704 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26705 void *argp1 = 0 ;
26706 int res1 = 0 ;
26707 PyObject *swig_obj[1] ;
26708
26709 if (!args) SWIG_fail;
26710 swig_obj[0] = args;
26711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26714 }
26715 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 delete arg1;
26719
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 resultobj = SWIG_Py_Void();
26724 return resultobj;
26725 fail:
26726 return NULL;
26727 }
26728
26729
26730 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26731 PyObject *resultobj = 0;
26732 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26733 PyObject *arg2 = (PyObject *) 0 ;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 PyObject * obj0 = 0 ;
26737 PyObject * obj1 = 0 ;
26738 char * kwnames[] = {
26739 (char *) "self",(char *) "self", NULL
26740 };
26741
26742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26744 if (!SWIG_IsOK(res1)) {
26745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26746 }
26747 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26748 arg2 = obj1;
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->SetSelf(arg2);
26752 wxPyEndAllowThreads(__tstate);
26753 if (PyErr_Occurred()) SWIG_fail;
26754 }
26755 resultobj = SWIG_Py_Void();
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26763 PyObject *resultobj = 0;
26764 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26765 PyObject *result = 0 ;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 PyObject *swig_obj[1] ;
26769
26770 if (!args) SWIG_fail;
26771 swig_obj[0] = args;
26772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26773 if (!SWIG_IsOK(res1)) {
26774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26775 }
26776 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (PyObject *)(arg1)->GetSelf();
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 resultobj = result;
26784 return resultobj;
26785 fail:
26786 return NULL;
26787 }
26788
26789
26790 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26791 PyObject *obj;
26792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26793 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26794 return SWIG_Py_Void();
26795 }
26796
26797 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 return SWIG_Python_InitShadowInstance(args);
26799 }
26800
26801 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26802 PyObject *resultobj = 0;
26803 wxWindow *arg1 = (wxWindow *) 0 ;
26804 wxDateTime *arg2 = 0 ;
26805 wxEventType arg3 ;
26806 wxDateEvent *result = 0 ;
26807 void *argp1 = 0 ;
26808 int res1 = 0 ;
26809 void *argp2 = 0 ;
26810 int res2 = 0 ;
26811 int val3 ;
26812 int ecode3 = 0 ;
26813 PyObject * obj0 = 0 ;
26814 PyObject * obj1 = 0 ;
26815 PyObject * obj2 = 0 ;
26816 char * kwnames[] = {
26817 (char *) "win",(char *) "dt",(char *) "type", NULL
26818 };
26819
26820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26824 }
26825 arg1 = reinterpret_cast< wxWindow * >(argp1);
26826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26827 if (!SWIG_IsOK(res2)) {
26828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26829 }
26830 if (!argp2) {
26831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26832 }
26833 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26834 ecode3 = SWIG_AsVal_int(obj2, &val3);
26835 if (!SWIG_IsOK(ecode3)) {
26836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26837 }
26838 arg3 = static_cast< wxEventType >(val3);
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26853 PyObject *resultobj = 0;
26854 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26855 wxDateTime *result = 0 ;
26856 void *argp1 = 0 ;
26857 int res1 = 0 ;
26858 PyObject *swig_obj[1] ;
26859
26860 if (!args) SWIG_fail;
26861 swig_obj[0] = args;
26862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26863 if (!SWIG_IsOK(res1)) {
26864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26865 }
26866 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26867 {
26868 PyThreadState* __tstate = wxPyBeginAllowThreads();
26869 {
26870 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26871 result = (wxDateTime *) &_result_ref;
26872 }
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26877 return resultobj;
26878 fail:
26879 return NULL;
26880 }
26881
26882
26883 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26884 PyObject *resultobj = 0;
26885 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26886 wxDateTime *arg2 = 0 ;
26887 void *argp1 = 0 ;
26888 int res1 = 0 ;
26889 void *argp2 = 0 ;
26890 int res2 = 0 ;
26891 PyObject * obj0 = 0 ;
26892 PyObject * obj1 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "self",(char *) "date", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26899 if (!SWIG_IsOK(res1)) {
26900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26901 }
26902 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26904 if (!SWIG_IsOK(res2)) {
26905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26906 }
26907 if (!argp2) {
26908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26909 }
26910 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 (arg1)->SetDate((wxDateTime const &)*arg2);
26914 wxPyEndAllowThreads(__tstate);
26915 if (PyErr_Occurred()) SWIG_fail;
26916 }
26917 resultobj = SWIG_Py_Void();
26918 return resultobj;
26919 fail:
26920 return NULL;
26921 }
26922
26923
26924 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26925 PyObject *obj;
26926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26927 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26928 return SWIG_Py_Void();
26929 }
26930
26931 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26932 return SWIG_Python_InitShadowInstance(args);
26933 }
26934
26935 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26936 PyObject *resultobj = 0;
26937 wxPyApp *result = 0 ;
26938
26939 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26940 {
26941 PyThreadState* __tstate = wxPyBeginAllowThreads();
26942 result = (wxPyApp *)new_wxPyApp();
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26954 PyObject *resultobj = 0;
26955 wxPyApp *arg1 = (wxPyApp *) 0 ;
26956 void *argp1 = 0 ;
26957 int res1 = 0 ;
26958 PyObject *swig_obj[1] ;
26959
26960 if (!args) SWIG_fail;
26961 swig_obj[0] = args;
26962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26963 if (!SWIG_IsOK(res1)) {
26964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26965 }
26966 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 delete arg1;
26970
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 resultobj = SWIG_Py_Void();
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj = 0;
26983 wxPyApp *arg1 = (wxPyApp *) 0 ;
26984 PyObject *arg2 = (PyObject *) 0 ;
26985 PyObject *arg3 = (PyObject *) 0 ;
26986 bool arg4 ;
26987 void *argp1 = 0 ;
26988 int res1 = 0 ;
26989 bool val4 ;
26990 int ecode4 = 0 ;
26991 PyObject * obj0 = 0 ;
26992 PyObject * obj1 = 0 ;
26993 PyObject * obj2 = 0 ;
26994 PyObject * obj3 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27003 }
27004 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27005 arg2 = obj1;
27006 arg3 = obj2;
27007 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27008 if (!SWIG_IsOK(ecode4)) {
27009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27010 }
27011 arg4 = static_cast< bool >(val4);
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27015 wxPyEndAllowThreads(__tstate);
27016 if (PyErr_Occurred()) SWIG_fail;
27017 }
27018 resultobj = SWIG_Py_Void();
27019 return resultobj;
27020 fail:
27021 return NULL;
27022 }
27023
27024
27025 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27026 PyObject *resultobj = 0;
27027 wxPyApp *arg1 = (wxPyApp *) 0 ;
27028 wxString result;
27029 void *argp1 = 0 ;
27030 int res1 = 0 ;
27031 PyObject *swig_obj[1] ;
27032
27033 if (!args) SWIG_fail;
27034 swig_obj[0] = args;
27035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27036 if (!SWIG_IsOK(res1)) {
27037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27038 }
27039 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 result = ((wxPyApp const *)arg1)->GetAppName();
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 {
27047 #if wxUSE_UNICODE
27048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27049 #else
27050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27051 #endif
27052 }
27053 return resultobj;
27054 fail:
27055 return NULL;
27056 }
27057
27058
27059 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27060 PyObject *resultobj = 0;
27061 wxPyApp *arg1 = (wxPyApp *) 0 ;
27062 wxString *arg2 = 0 ;
27063 void *argp1 = 0 ;
27064 int res1 = 0 ;
27065 bool temp2 = false ;
27066 PyObject * obj0 = 0 ;
27067 PyObject * obj1 = 0 ;
27068 char * kwnames[] = {
27069 (char *) "self",(char *) "name", NULL
27070 };
27071
27072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27074 if (!SWIG_IsOK(res1)) {
27075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27076 }
27077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27078 {
27079 arg2 = wxString_in_helper(obj1);
27080 if (arg2 == NULL) SWIG_fail;
27081 temp2 = true;
27082 }
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 (arg1)->SetAppName((wxString const &)*arg2);
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 resultobj = SWIG_Py_Void();
27090 {
27091 if (temp2)
27092 delete arg2;
27093 }
27094 return resultobj;
27095 fail:
27096 {
27097 if (temp2)
27098 delete arg2;
27099 }
27100 return NULL;
27101 }
27102
27103
27104 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 PyObject *resultobj = 0;
27106 wxPyApp *arg1 = (wxPyApp *) 0 ;
27107 wxString result;
27108 void *argp1 = 0 ;
27109 int res1 = 0 ;
27110 PyObject *swig_obj[1] ;
27111
27112 if (!args) SWIG_fail;
27113 swig_obj[0] = args;
27114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27117 }
27118 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = ((wxPyApp const *)arg1)->GetClassName();
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 #if wxUSE_UNICODE
27127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27128 #else
27129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27130 #endif
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxPyApp *arg1 = (wxPyApp *) 0 ;
27141 wxString *arg2 = 0 ;
27142 void *argp1 = 0 ;
27143 int res1 = 0 ;
27144 bool temp2 = false ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char * kwnames[] = {
27148 (char *) "self",(char *) "name", NULL
27149 };
27150
27151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27155 }
27156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27157 {
27158 arg2 = wxString_in_helper(obj1);
27159 if (arg2 == NULL) SWIG_fail;
27160 temp2 = true;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->SetClassName((wxString const &)*arg2);
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_Py_Void();
27169 {
27170 if (temp2)
27171 delete arg2;
27172 }
27173 return resultobj;
27174 fail:
27175 {
27176 if (temp2)
27177 delete arg2;
27178 }
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27184 PyObject *resultobj = 0;
27185 wxPyApp *arg1 = (wxPyApp *) 0 ;
27186 wxString *result = 0 ;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject *swig_obj[1] ;
27190
27191 if (!args) SWIG_fail;
27192 swig_obj[0] = args;
27193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27196 }
27197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 {
27201 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27202 result = (wxString *) &_result_ref;
27203 }
27204 wxPyEndAllowThreads(__tstate);
27205 if (PyErr_Occurred()) SWIG_fail;
27206 }
27207 {
27208 #if wxUSE_UNICODE
27209 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27210 #else
27211 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27212 #endif
27213 }
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj = 0;
27222 wxPyApp *arg1 = (wxPyApp *) 0 ;
27223 wxString *arg2 = 0 ;
27224 void *argp1 = 0 ;
27225 int res1 = 0 ;
27226 bool temp2 = false ;
27227 PyObject * obj0 = 0 ;
27228 PyObject * obj1 = 0 ;
27229 char * kwnames[] = {
27230 (char *) "self",(char *) "name", NULL
27231 };
27232
27233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27237 }
27238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27239 {
27240 arg2 = wxString_in_helper(obj1);
27241 if (arg2 == NULL) SWIG_fail;
27242 temp2 = true;
27243 }
27244 {
27245 PyThreadState* __tstate = wxPyBeginAllowThreads();
27246 (arg1)->SetVendorName((wxString const &)*arg2);
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 resultobj = SWIG_Py_Void();
27251 {
27252 if (temp2)
27253 delete arg2;
27254 }
27255 return resultobj;
27256 fail:
27257 {
27258 if (temp2)
27259 delete arg2;
27260 }
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxPyApp *arg1 = (wxPyApp *) 0 ;
27268 wxAppTraits *result = 0 ;
27269 void *argp1 = 0 ;
27270 int res1 = 0 ;
27271 PyObject *swig_obj[1] ;
27272
27273 if (!args) SWIG_fail;
27274 swig_obj[0] = args;
27275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27276 if (!SWIG_IsOK(res1)) {
27277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27278 }
27279 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (wxAppTraits *)(arg1)->GetTraits();
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27294 PyObject *resultobj = 0;
27295 wxPyApp *arg1 = (wxPyApp *) 0 ;
27296 void *argp1 = 0 ;
27297 int res1 = 0 ;
27298 PyObject *swig_obj[1] ;
27299
27300 if (!args) SWIG_fail;
27301 swig_obj[0] = args;
27302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27303 if (!SWIG_IsOK(res1)) {
27304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27305 }
27306 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 (arg1)->ProcessPendingEvents();
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 resultobj = SWIG_Py_Void();
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj = 0;
27322 wxPyApp *arg1 = (wxPyApp *) 0 ;
27323 bool arg2 = (bool) false ;
27324 bool result;
27325 void *argp1 = 0 ;
27326 int res1 = 0 ;
27327 bool val2 ;
27328 int ecode2 = 0 ;
27329 PyObject * obj0 = 0 ;
27330 PyObject * obj1 = 0 ;
27331 char * kwnames[] = {
27332 (char *) "self",(char *) "onlyIfNeeded", NULL
27333 };
27334
27335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27339 }
27340 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27341 if (obj1) {
27342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27343 if (!SWIG_IsOK(ecode2)) {
27344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27345 }
27346 arg2 = static_cast< bool >(val2);
27347 }
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 result = (bool)(arg1)->Yield(arg2);
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 {
27355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27356 }
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27364 PyObject *resultobj = 0;
27365 wxPyApp *arg1 = (wxPyApp *) 0 ;
27366 void *argp1 = 0 ;
27367 int res1 = 0 ;
27368 PyObject *swig_obj[1] ;
27369
27370 if (!args) SWIG_fail;
27371 swig_obj[0] = args;
27372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27373 if (!SWIG_IsOK(res1)) {
27374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27375 }
27376 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27377 {
27378 PyThreadState* __tstate = wxPyBeginAllowThreads();
27379 (arg1)->WakeUpIdle();
27380 wxPyEndAllowThreads(__tstate);
27381 if (PyErr_Occurred()) SWIG_fail;
27382 }
27383 resultobj = SWIG_Py_Void();
27384 return resultobj;
27385 fail:
27386 return NULL;
27387 }
27388
27389
27390 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27391 PyObject *resultobj = 0;
27392 bool result;
27393
27394 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27395 {
27396 PyThreadState* __tstate = wxPyBeginAllowThreads();
27397 result = (bool)wxPyApp::IsMainLoopRunning();
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 {
27402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27403 }
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxPyApp *arg1 = (wxPyApp *) 0 ;
27413 int result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27423 }
27424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (int)(arg1)->MainLoop();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_From_int(static_cast< int >(result));
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxPyApp *arg1 = (wxPyApp *) 0 ;
27441 void *argp1 = 0 ;
27442 int res1 = 0 ;
27443 PyObject *swig_obj[1] ;
27444
27445 if (!args) SWIG_fail;
27446 swig_obj[0] = args;
27447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 (arg1)->Exit();
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 resultobj = SWIG_Py_Void();
27459 return resultobj;
27460 fail:
27461 return NULL;
27462 }
27463
27464
27465 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27466 PyObject *resultobj = 0;
27467 wxPyApp *arg1 = (wxPyApp *) 0 ;
27468 void *argp1 = 0 ;
27469 int res1 = 0 ;
27470 PyObject *swig_obj[1] ;
27471
27472 if (!args) SWIG_fail;
27473 swig_obj[0] = args;
27474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27475 if (!SWIG_IsOK(res1)) {
27476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27477 }
27478 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 (arg1)->ExitMainLoop();
27482 wxPyEndAllowThreads(__tstate);
27483 if (PyErr_Occurred()) SWIG_fail;
27484 }
27485 resultobj = SWIG_Py_Void();
27486 return resultobj;
27487 fail:
27488 return NULL;
27489 }
27490
27491
27492 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27493 PyObject *resultobj = 0;
27494 wxPyApp *arg1 = (wxPyApp *) 0 ;
27495 bool result;
27496 void *argp1 = 0 ;
27497 int res1 = 0 ;
27498 PyObject *swig_obj[1] ;
27499
27500 if (!args) SWIG_fail;
27501 swig_obj[0] = args;
27502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27503 if (!SWIG_IsOK(res1)) {
27504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27505 }
27506 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27507 {
27508 PyThreadState* __tstate = wxPyBeginAllowThreads();
27509 result = (bool)(arg1)->Pending();
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27515 }
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27523 PyObject *resultobj = 0;
27524 wxPyApp *arg1 = (wxPyApp *) 0 ;
27525 bool result;
27526 void *argp1 = 0 ;
27527 int res1 = 0 ;
27528 PyObject *swig_obj[1] ;
27529
27530 if (!args) SWIG_fail;
27531 swig_obj[0] = args;
27532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27533 if (!SWIG_IsOK(res1)) {
27534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27535 }
27536 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = (bool)(arg1)->Dispatch();
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 {
27544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27545 }
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27553 PyObject *resultobj = 0;
27554 wxPyApp *arg1 = (wxPyApp *) 0 ;
27555 bool result;
27556 void *argp1 = 0 ;
27557 int res1 = 0 ;
27558 PyObject *swig_obj[1] ;
27559
27560 if (!args) SWIG_fail;
27561 swig_obj[0] = args;
27562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27563 if (!SWIG_IsOK(res1)) {
27564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27565 }
27566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (bool)(arg1)->ProcessIdle();
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 {
27574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27575 }
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj = 0;
27584 wxPyApp *arg1 = (wxPyApp *) 0 ;
27585 wxWindow *arg2 = (wxWindow *) 0 ;
27586 wxIdleEvent *arg3 = 0 ;
27587 bool result;
27588 void *argp1 = 0 ;
27589 int res1 = 0 ;
27590 void *argp2 = 0 ;
27591 int res2 = 0 ;
27592 void *argp3 = 0 ;
27593 int res3 = 0 ;
27594 PyObject * obj0 = 0 ;
27595 PyObject * obj1 = 0 ;
27596 PyObject * obj2 = 0 ;
27597 char * kwnames[] = {
27598 (char *) "self",(char *) "win",(char *) "event", NULL
27599 };
27600
27601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27603 if (!SWIG_IsOK(res1)) {
27604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27605 }
27606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27608 if (!SWIG_IsOK(res2)) {
27609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27610 }
27611 arg2 = reinterpret_cast< wxWindow * >(argp2);
27612 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27613 if (!SWIG_IsOK(res3)) {
27614 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27615 }
27616 if (!argp3) {
27617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27618 }
27619 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 {
27627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27628 }
27629 return resultobj;
27630 fail:
27631 return NULL;
27632 }
27633
27634
27635 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27636 PyObject *resultobj = 0;
27637 wxPyApp *arg1 = (wxPyApp *) 0 ;
27638 bool result;
27639 void *argp1 = 0 ;
27640 int res1 = 0 ;
27641 PyObject *swig_obj[1] ;
27642
27643 if (!args) SWIG_fail;
27644 swig_obj[0] = args;
27645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27646 if (!SWIG_IsOK(res1)) {
27647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27648 }
27649 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (bool)((wxPyApp const *)arg1)->IsActive();
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 {
27657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27658 }
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj = 0;
27667 wxPyApp *arg1 = (wxPyApp *) 0 ;
27668 wxWindow *arg2 = (wxWindow *) 0 ;
27669 void *argp1 = 0 ;
27670 int res1 = 0 ;
27671 void *argp2 = 0 ;
27672 int res2 = 0 ;
27673 PyObject * obj0 = 0 ;
27674 PyObject * obj1 = 0 ;
27675 char * kwnames[] = {
27676 (char *) "self",(char *) "win", NULL
27677 };
27678
27679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27681 if (!SWIG_IsOK(res1)) {
27682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27683 }
27684 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27686 if (!SWIG_IsOK(res2)) {
27687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27688 }
27689 arg2 = reinterpret_cast< wxWindow * >(argp2);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 (arg1)->SetTopWindow(arg2);
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_Py_Void();
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27704 PyObject *resultobj = 0;
27705 wxPyApp *arg1 = (wxPyApp *) 0 ;
27706 wxWindow *result = 0 ;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 PyObject *swig_obj[1] ;
27710
27711 if (!args) SWIG_fail;
27712 swig_obj[0] = args;
27713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27716 }
27717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 {
27725 resultobj = wxPyMake_wxObject(result, (bool)0);
27726 }
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27734 PyObject *resultobj = 0;
27735 wxPyApp *arg1 = (wxPyApp *) 0 ;
27736 bool arg2 ;
27737 void *argp1 = 0 ;
27738 int res1 = 0 ;
27739 bool val2 ;
27740 int ecode2 = 0 ;
27741 PyObject * obj0 = 0 ;
27742 PyObject * obj1 = 0 ;
27743 char * kwnames[] = {
27744 (char *) "self",(char *) "flag", NULL
27745 };
27746
27747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27751 }
27752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27754 if (!SWIG_IsOK(ecode2)) {
27755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27756 }
27757 arg2 = static_cast< bool >(val2);
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 (arg1)->SetExitOnFrameDelete(arg2);
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_Py_Void();
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27772 PyObject *resultobj = 0;
27773 wxPyApp *arg1 = (wxPyApp *) 0 ;
27774 bool result;
27775 void *argp1 = 0 ;
27776 int res1 = 0 ;
27777 PyObject *swig_obj[1] ;
27778
27779 if (!args) SWIG_fail;
27780 swig_obj[0] = args;
27781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27782 if (!SWIG_IsOK(res1)) {
27783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27784 }
27785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 {
27793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27794 }
27795 return resultobj;
27796 fail:
27797 return NULL;
27798 }
27799
27800
27801 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27802 PyObject *resultobj = 0;
27803 wxPyApp *arg1 = (wxPyApp *) 0 ;
27804 bool arg2 ;
27805 void *argp1 = 0 ;
27806 int res1 = 0 ;
27807 bool val2 ;
27808 int ecode2 = 0 ;
27809 PyObject * obj0 = 0 ;
27810 PyObject * obj1 = 0 ;
27811 char * kwnames[] = {
27812 (char *) "self",(char *) "flag", NULL
27813 };
27814
27815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27817 if (!SWIG_IsOK(res1)) {
27818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27819 }
27820 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27822 if (!SWIG_IsOK(ecode2)) {
27823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27824 }
27825 arg2 = static_cast< bool >(val2);
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 (arg1)->SetUseBestVisual(arg2);
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 resultobj = SWIG_Py_Void();
27833 return resultobj;
27834 fail:
27835 return NULL;
27836 }
27837
27838
27839 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27840 PyObject *resultobj = 0;
27841 wxPyApp *arg1 = (wxPyApp *) 0 ;
27842 bool result;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 PyObject *swig_obj[1] ;
27846
27847 if (!args) SWIG_fail;
27848 swig_obj[0] = args;
27849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27850 if (!SWIG_IsOK(res1)) {
27851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27852 }
27853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 {
27861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj = 0;
27871 wxPyApp *arg1 = (wxPyApp *) 0 ;
27872 int arg2 ;
27873 void *argp1 = 0 ;
27874 int res1 = 0 ;
27875 int val2 ;
27876 int ecode2 = 0 ;
27877 PyObject * obj0 = 0 ;
27878 PyObject * obj1 = 0 ;
27879 char * kwnames[] = {
27880 (char *) "self",(char *) "mode", NULL
27881 };
27882
27883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27885 if (!SWIG_IsOK(res1)) {
27886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27887 }
27888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27889 ecode2 = SWIG_AsVal_int(obj1, &val2);
27890 if (!SWIG_IsOK(ecode2)) {
27891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27892 }
27893 arg2 = static_cast< int >(val2);
27894 {
27895 PyThreadState* __tstate = wxPyBeginAllowThreads();
27896 (arg1)->SetPrintMode(arg2);
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_Py_Void();
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27908 PyObject *resultobj = 0;
27909 wxPyApp *arg1 = (wxPyApp *) 0 ;
27910 int result;
27911 void *argp1 = 0 ;
27912 int res1 = 0 ;
27913 PyObject *swig_obj[1] ;
27914
27915 if (!args) SWIG_fail;
27916 swig_obj[0] = args;
27917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27918 if (!SWIG_IsOK(res1)) {
27919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27920 }
27921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 resultobj = SWIG_From_int(static_cast< int >(result));
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27936 PyObject *resultobj = 0;
27937 wxPyApp *arg1 = (wxPyApp *) 0 ;
27938 int arg2 ;
27939 void *argp1 = 0 ;
27940 int res1 = 0 ;
27941 int val2 ;
27942 int ecode2 = 0 ;
27943 PyObject * obj0 = 0 ;
27944 PyObject * obj1 = 0 ;
27945 char * kwnames[] = {
27946 (char *) "self",(char *) "mode", NULL
27947 };
27948
27949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27951 if (!SWIG_IsOK(res1)) {
27952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27953 }
27954 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27955 ecode2 = SWIG_AsVal_int(obj1, &val2);
27956 if (!SWIG_IsOK(ecode2)) {
27957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27958 }
27959 arg2 = static_cast< int >(val2);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 (arg1)->SetAssertMode(arg2);
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 resultobj = SWIG_Py_Void();
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27974 PyObject *resultobj = 0;
27975 wxPyApp *arg1 = (wxPyApp *) 0 ;
27976 int result;
27977 void *argp1 = 0 ;
27978 int res1 = 0 ;
27979 PyObject *swig_obj[1] ;
27980
27981 if (!args) SWIG_fail;
27982 swig_obj[0] = args;
27983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27984 if (!SWIG_IsOK(res1)) {
27985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27986 }
27987 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (int)(arg1)->GetAssertMode();
27991 wxPyEndAllowThreads(__tstate);
27992 if (PyErr_Occurred()) SWIG_fail;
27993 }
27994 resultobj = SWIG_From_int(static_cast< int >(result));
27995 return resultobj;
27996 fail:
27997 return NULL;
27998 }
27999
28000
28001 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28002 PyObject *resultobj = 0;
28003 bool result;
28004
28005 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 long result;
28024
28025 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = (long)wxPyApp::GetMacAboutMenuItemId();
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_From_long(static_cast< long >(result));
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28040 PyObject *resultobj = 0;
28041 long result;
28042
28043 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_From_long(static_cast< long >(result));
28051 return resultobj;
28052 fail:
28053 return NULL;
28054 }
28055
28056
28057 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28058 PyObject *resultobj = 0;
28059 long result;
28060
28061 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 result = (long)wxPyApp::GetMacExitMenuItemId();
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_From_long(static_cast< long >(result));
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28076 PyObject *resultobj = 0;
28077 wxString result;
28078
28079 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28080 {
28081 PyThreadState* __tstate = wxPyBeginAllowThreads();
28082 result = wxPyApp::GetMacHelpMenuTitleName();
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 {
28087 #if wxUSE_UNICODE
28088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28089 #else
28090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28091 #endif
28092 }
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28100 PyObject *resultobj = 0;
28101 bool arg1 ;
28102 bool val1 ;
28103 int ecode1 = 0 ;
28104 PyObject * obj0 = 0 ;
28105 char * kwnames[] = {
28106 (char *) "val", NULL
28107 };
28108
28109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28110 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28111 if (!SWIG_IsOK(ecode1)) {
28112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28113 }
28114 arg1 = static_cast< bool >(val1);
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 resultobj = SWIG_Py_Void();
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 long arg1 ;
28131 long val1 ;
28132 int ecode1 = 0 ;
28133 PyObject * obj0 = 0 ;
28134 char * kwnames[] = {
28135 (char *) "val", NULL
28136 };
28137
28138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28139 ecode1 = SWIG_AsVal_long(obj0, &val1);
28140 if (!SWIG_IsOK(ecode1)) {
28141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28142 }
28143 arg1 = static_cast< long >(val1);
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 wxPyApp::SetMacAboutMenuItemId(arg1);
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 resultobj = SWIG_Py_Void();
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28158 PyObject *resultobj = 0;
28159 long arg1 ;
28160 long val1 ;
28161 int ecode1 = 0 ;
28162 PyObject * obj0 = 0 ;
28163 char * kwnames[] = {
28164 (char *) "val", NULL
28165 };
28166
28167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28168 ecode1 = SWIG_AsVal_long(obj0, &val1);
28169 if (!SWIG_IsOK(ecode1)) {
28170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28171 }
28172 arg1 = static_cast< long >(val1);
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_Py_Void();
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28187 PyObject *resultobj = 0;
28188 long arg1 ;
28189 long val1 ;
28190 int ecode1 = 0 ;
28191 PyObject * obj0 = 0 ;
28192 char * kwnames[] = {
28193 (char *) "val", NULL
28194 };
28195
28196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28197 ecode1 = SWIG_AsVal_long(obj0, &val1);
28198 if (!SWIG_IsOK(ecode1)) {
28199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28200 }
28201 arg1 = static_cast< long >(val1);
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 wxPyApp::SetMacExitMenuItemId(arg1);
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 resultobj = SWIG_Py_Void();
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj = 0;
28217 wxString *arg1 = 0 ;
28218 bool temp1 = false ;
28219 PyObject * obj0 = 0 ;
28220 char * kwnames[] = {
28221 (char *) "val", NULL
28222 };
28223
28224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28225 {
28226 arg1 = wxString_in_helper(obj0);
28227 if (arg1 == NULL) SWIG_fail;
28228 temp1 = true;
28229 }
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 resultobj = SWIG_Py_Void();
28237 {
28238 if (temp1)
28239 delete arg1;
28240 }
28241 return resultobj;
28242 fail:
28243 {
28244 if (temp1)
28245 delete arg1;
28246 }
28247 return NULL;
28248 }
28249
28250
28251 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28252 PyObject *resultobj = 0;
28253 wxPyApp *arg1 = (wxPyApp *) 0 ;
28254 void *argp1 = 0 ;
28255 int res1 = 0 ;
28256 PyObject *swig_obj[1] ;
28257
28258 if (!args) SWIG_fail;
28259 swig_obj[0] = args;
28260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28261 if (!SWIG_IsOK(res1)) {
28262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28263 }
28264 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 (arg1)->_BootstrapApp();
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_Py_Void();
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28279 PyObject *resultobj = 0;
28280 int result;
28281
28282 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (int)wxPyApp::GetComCtl32Version();
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_From_int(static_cast< int >(result));
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28297 PyObject *obj;
28298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28299 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28300 return SWIG_Py_Void();
28301 }
28302
28303 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28304 return SWIG_Python_InitShadowInstance(args);
28305 }
28306
28307 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 wxExit();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_Py_Void();
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *resultobj = 0;
28326 bool result;
28327
28328 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (bool)wxYield();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 bool result;
28347
28348 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (bool)wxYieldIfNeeded();
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 wxWindow *arg1 = (wxWindow *) NULL ;
28367 bool arg2 = (bool) false ;
28368 bool result;
28369 void *argp1 = 0 ;
28370 int res1 = 0 ;
28371 bool val2 ;
28372 int ecode2 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 PyObject * obj1 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "win",(char *) "onlyIfNeeded", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28380 if (obj0) {
28381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28382 if (!SWIG_IsOK(res1)) {
28383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28384 }
28385 arg1 = reinterpret_cast< wxWindow * >(argp1);
28386 }
28387 if (obj1) {
28388 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28389 if (!SWIG_IsOK(ecode2)) {
28390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28391 }
28392 arg2 = static_cast< bool >(val2);
28393 }
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (bool)wxSafeYield(arg1,arg2);
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 {
28401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28402 }
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *resultobj = 0;
28411
28412 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 wxWakeUpIdle();
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 resultobj = SWIG_Py_Void();
28420 return resultobj;
28421 fail:
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28427 PyObject *resultobj = 0;
28428 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28429 wxEvent *arg2 = 0 ;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 void *argp2 = 0 ;
28433 int res2 = 0 ;
28434 PyObject * obj0 = 0 ;
28435 PyObject * obj1 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "dest",(char *) "event", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28444 }
28445 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28447 if (!SWIG_IsOK(res2)) {
28448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28449 }
28450 if (!argp2) {
28451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28452 }
28453 arg2 = reinterpret_cast< wxEvent * >(argp2);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 wxPostEvent(arg1,*arg2);
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 resultobj = SWIG_Py_Void();
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28468 PyObject *resultobj = 0;
28469
28470 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 wxApp_CleanUp();
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 resultobj = SWIG_Py_Void();
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28485 PyObject *resultobj = 0;
28486 wxPyApp *result = 0 ;
28487
28488 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (wxPyApp *)wxPyGetApp();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = wxPyMake_wxObject(result, 0);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj = 0;
28506 char *arg1 = (char *) 0 ;
28507 int res1 ;
28508 char *buf1 = 0 ;
28509 int alloc1 = 0 ;
28510 PyObject * obj0 = 0 ;
28511 char * kwnames[] = {
28512 (char *) "encoding", NULL
28513 };
28514
28515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28516 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28517 if (!SWIG_IsOK(res1)) {
28518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28519 }
28520 arg1 = buf1;
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 wxSetDefaultPyEncoding((char const *)arg1);
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 resultobj = SWIG_Py_Void();
28528 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28529 return resultobj;
28530 fail:
28531 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28532 return NULL;
28533 }
28534
28535
28536 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28537 PyObject *resultobj = 0;
28538 char *result = 0 ;
28539
28540 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (char *)wxGetDefaultPyEncoding();
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 resultobj = SWIG_FromCharPtr(result);
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28555 PyObject *resultobj = 0;
28556 wxEventLoop *result = 0 ;
28557
28558 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (wxEventLoop *)new wxEventLoop();
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28573 PyObject *resultobj = 0;
28574 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 PyObject *swig_obj[1] ;
28578
28579 if (!args) SWIG_fail;
28580 swig_obj[0] = args;
28581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28584 }
28585 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 delete arg1;
28589
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 resultobj = SWIG_Py_Void();
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28601 PyObject *resultobj = 0;
28602 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28603 int result;
28604 void *argp1 = 0 ;
28605 int res1 = 0 ;
28606 PyObject *swig_obj[1] ;
28607
28608 if (!args) SWIG_fail;
28609 swig_obj[0] = args;
28610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28611 if (!SWIG_IsOK(res1)) {
28612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28613 }
28614 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (int)(arg1)->Run();
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 resultobj = SWIG_From_int(static_cast< int >(result));
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28629 PyObject *resultobj = 0;
28630 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28631 int arg2 = (int) 0 ;
28632 void *argp1 = 0 ;
28633 int res1 = 0 ;
28634 int val2 ;
28635 int ecode2 = 0 ;
28636 PyObject * obj0 = 0 ;
28637 PyObject * obj1 = 0 ;
28638 char * kwnames[] = {
28639 (char *) "self",(char *) "rc", NULL
28640 };
28641
28642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28644 if (!SWIG_IsOK(res1)) {
28645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28646 }
28647 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28648 if (obj1) {
28649 ecode2 = SWIG_AsVal_int(obj1, &val2);
28650 if (!SWIG_IsOK(ecode2)) {
28651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28652 }
28653 arg2 = static_cast< int >(val2);
28654 }
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 (arg1)->Exit(arg2);
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_Py_Void();
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *resultobj = 0;
28670 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28671 bool result;
28672 void *argp1 = 0 ;
28673 int res1 = 0 ;
28674 PyObject *swig_obj[1] ;
28675
28676 if (!args) SWIG_fail;
28677 swig_obj[0] = args;
28678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28679 if (!SWIG_IsOK(res1)) {
28680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28681 }
28682 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)((wxEventLoop const *)arg1)->Pending();
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 {
28690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28691 }
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28699 PyObject *resultobj = 0;
28700 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28701 bool result;
28702 void *argp1 = 0 ;
28703 int res1 = 0 ;
28704 PyObject *swig_obj[1] ;
28705
28706 if (!args) SWIG_fail;
28707 swig_obj[0] = args;
28708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28709 if (!SWIG_IsOK(res1)) {
28710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28711 }
28712 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = (bool)(arg1)->Dispatch();
28716 wxPyEndAllowThreads(__tstate);
28717 if (PyErr_Occurred()) SWIG_fail;
28718 }
28719 {
28720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28721 }
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28731 bool result;
28732 void *argp1 = 0 ;
28733 int res1 = 0 ;
28734 PyObject *swig_obj[1] ;
28735
28736 if (!args) SWIG_fail;
28737 swig_obj[0] = args;
28738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28741 }
28742 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28759 PyObject *resultobj = 0;
28760 wxEventLoop *result = 0 ;
28761
28762 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (wxEventLoop *)wxEventLoop::GetActive();
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28777 PyObject *resultobj = 0;
28778 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 PyObject * obj0 = 0 ;
28782 char * kwnames[] = {
28783 (char *) "loop", NULL
28784 };
28785
28786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28788 if (!SWIG_IsOK(res1)) {
28789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28790 }
28791 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 wxEventLoop::SetActive(arg1);
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 resultobj = SWIG_Py_Void();
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28806 PyObject *obj;
28807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28808 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28809 return SWIG_Py_Void();
28810 }
28811
28812 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28813 return SWIG_Python_InitShadowInstance(args);
28814 }
28815
28816 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28817 PyObject *resultobj = 0;
28818 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28819 wxEventLoopActivator *result = 0 ;
28820 void *argp1 = 0 ;
28821 int res1 = 0 ;
28822 PyObject * obj0 = 0 ;
28823 char * kwnames[] = {
28824 (char *) "evtLoop", NULL
28825 };
28826
28827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28829 if (!SWIG_IsOK(res1)) {
28830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28831 }
28832 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28833 {
28834 PyThreadState* __tstate = wxPyBeginAllowThreads();
28835 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28836 wxPyEndAllowThreads(__tstate);
28837 if (PyErr_Occurred()) SWIG_fail;
28838 }
28839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28847 PyObject *resultobj = 0;
28848 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28849 void *argp1 = 0 ;
28850 int res1 = 0 ;
28851 PyObject *swig_obj[1] ;
28852
28853 if (!args) SWIG_fail;
28854 swig_obj[0] = args;
28855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28856 if (!SWIG_IsOK(res1)) {
28857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28858 }
28859 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 delete arg1;
28863
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_Py_Void();
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28875 PyObject *obj;
28876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28877 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28878 return SWIG_Py_Void();
28879 }
28880
28881 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28882 return SWIG_Python_InitShadowInstance(args);
28883 }
28884
28885 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj = 0;
28887 int arg1 = (int) 0 ;
28888 int arg2 = (int) 0 ;
28889 int arg3 = (int) 0 ;
28890 wxAcceleratorEntry *result = 0 ;
28891 int val1 ;
28892 int ecode1 = 0 ;
28893 int val2 ;
28894 int ecode2 = 0 ;
28895 int val3 ;
28896 int ecode3 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 PyObject * obj2 = 0 ;
28900 char * kwnames[] = {
28901 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28902 };
28903
28904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28905 if (obj0) {
28906 ecode1 = SWIG_AsVal_int(obj0, &val1);
28907 if (!SWIG_IsOK(ecode1)) {
28908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28909 }
28910 arg1 = static_cast< int >(val1);
28911 }
28912 if (obj1) {
28913 ecode2 = SWIG_AsVal_int(obj1, &val2);
28914 if (!SWIG_IsOK(ecode2)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28916 }
28917 arg2 = static_cast< int >(val2);
28918 }
28919 if (obj2) {
28920 ecode3 = SWIG_AsVal_int(obj2, &val3);
28921 if (!SWIG_IsOK(ecode3)) {
28922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28923 }
28924 arg3 = static_cast< int >(val3);
28925 }
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28942 void *argp1 = 0 ;
28943 int res1 = 0 ;
28944 PyObject *swig_obj[1] ;
28945
28946 if (!args) SWIG_fail;
28947 swig_obj[0] = args;
28948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28949 if (!SWIG_IsOK(res1)) {
28950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28951 }
28952 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 delete arg1;
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_Py_Void();
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj = 0;
28969 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28970 int arg2 ;
28971 int arg3 ;
28972 int arg4 ;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 int val2 ;
28976 int ecode2 = 0 ;
28977 int val3 ;
28978 int ecode3 = 0 ;
28979 int val4 ;
28980 int ecode4 = 0 ;
28981 PyObject * obj0 = 0 ;
28982 PyObject * obj1 = 0 ;
28983 PyObject * obj2 = 0 ;
28984 PyObject * obj3 = 0 ;
28985 char * kwnames[] = {
28986 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28987 };
28988
28989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28991 if (!SWIG_IsOK(res1)) {
28992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28993 }
28994 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28995 ecode2 = SWIG_AsVal_int(obj1, &val2);
28996 if (!SWIG_IsOK(ecode2)) {
28997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28998 }
28999 arg2 = static_cast< int >(val2);
29000 ecode3 = SWIG_AsVal_int(obj2, &val3);
29001 if (!SWIG_IsOK(ecode3)) {
29002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29003 }
29004 arg3 = static_cast< int >(val3);
29005 ecode4 = SWIG_AsVal_int(obj3, &val4);
29006 if (!SWIG_IsOK(ecode4)) {
29007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29008 }
29009 arg4 = static_cast< int >(val4);
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 (arg1)->Set(arg2,arg3,arg4);
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_Py_Void();
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *resultobj = 0;
29025 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29026 int result;
29027 void *argp1 = 0 ;
29028 int res1 = 0 ;
29029 PyObject *swig_obj[1] ;
29030
29031 if (!args) SWIG_fail;
29032 swig_obj[0] = args;
29033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29036 }
29037 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (int)(arg1)->GetFlags();
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 resultobj = SWIG_From_int(static_cast< int >(result));
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 PyObject *resultobj = 0;
29053 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29054 int result;
29055 void *argp1 = 0 ;
29056 int res1 = 0 ;
29057 PyObject *swig_obj[1] ;
29058
29059 if (!args) SWIG_fail;
29060 swig_obj[0] = args;
29061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29062 if (!SWIG_IsOK(res1)) {
29063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29064 }
29065 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29066 {
29067 PyThreadState* __tstate = wxPyBeginAllowThreads();
29068 result = (int)(arg1)->GetKeyCode();
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_From_int(static_cast< int >(result));
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29080 PyObject *resultobj = 0;
29081 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29082 int result;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject *swig_obj[1] ;
29086
29087 if (!args) SWIG_fail;
29088 swig_obj[0] = args;
29089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29090 if (!SWIG_IsOK(res1)) {
29091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29092 }
29093 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (int)(arg1)->GetCommand();
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_From_int(static_cast< int >(result));
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *obj;
29109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29110 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29111 return SWIG_Py_Void();
29112 }
29113
29114 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29115 return SWIG_Python_InitShadowInstance(args);
29116 }
29117
29118 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj = 0;
29120 int arg1 ;
29121 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29122 wxAcceleratorTable *result = 0 ;
29123 PyObject * obj0 = 0 ;
29124 char * kwnames[] = {
29125 (char *) "n", NULL
29126 };
29127
29128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29129 {
29130 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29131 if (arg2) arg1 = PyList_Size(obj0);
29132 else arg1 = 0;
29133 }
29134 {
29135 PyThreadState* __tstate = wxPyBeginAllowThreads();
29136 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29137 wxPyEndAllowThreads(__tstate);
29138 if (PyErr_Occurred()) SWIG_fail;
29139 }
29140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29148 PyObject *resultobj = 0;
29149 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29150 void *argp1 = 0 ;
29151 int res1 = 0 ;
29152 PyObject *swig_obj[1] ;
29153
29154 if (!args) SWIG_fail;
29155 swig_obj[0] = args;
29156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29157 if (!SWIG_IsOK(res1)) {
29158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29159 }
29160 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 delete arg1;
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 resultobj = SWIG_Py_Void();
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29176 PyObject *resultobj = 0;
29177 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29178 bool result;
29179 void *argp1 = 0 ;
29180 int res1 = 0 ;
29181 PyObject *swig_obj[1] ;
29182
29183 if (!args) SWIG_fail;
29184 swig_obj[0] = args;
29185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29186 if (!SWIG_IsOK(res1)) {
29187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29188 }
29189 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 {
29197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29198 }
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *obj;
29207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29208 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29209 return SWIG_Py_Void();
29210 }
29211
29212 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29213 return SWIG_Python_InitShadowInstance(args);
29214 }
29215
29216 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29217 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29218 return 1;
29219 }
29220
29221
29222 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29223 PyObject *pyobj = 0;
29224
29225 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29226 return pyobj;
29227 }
29228
29229
29230 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj = 0;
29232 wxString *arg1 = 0 ;
29233 wxAcceleratorEntry *result = 0 ;
29234 bool temp1 = false ;
29235 PyObject * obj0 = 0 ;
29236 char * kwnames[] = {
29237 (char *) "label", NULL
29238 };
29239
29240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29241 {
29242 arg1 = wxString_in_helper(obj0);
29243 if (arg1 == NULL) SWIG_fail;
29244 temp1 = true;
29245 }
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29253 {
29254 if (temp1)
29255 delete arg1;
29256 }
29257 return resultobj;
29258 fail:
29259 {
29260 if (temp1)
29261 delete arg1;
29262 }
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN int PanelNameStr_set(PyObject *) {
29268 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29269 return 1;
29270 }
29271
29272
29273 SWIGINTERN PyObject *PanelNameStr_get(void) {
29274 PyObject *pyobj = 0;
29275
29276 {
29277 #if wxUSE_UNICODE
29278 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29279 #else
29280 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29281 #endif
29282 }
29283 return pyobj;
29284 }
29285
29286
29287 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29288 PyObject *resultobj = 0;
29289 wxVisualAttributes *result = 0 ;
29290
29291 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 result = (wxVisualAttributes *)new_wxVisualAttributes();
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29306 PyObject *resultobj = 0;
29307 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29308 void *argp1 = 0 ;
29309 int res1 = 0 ;
29310 PyObject *swig_obj[1] ;
29311
29312 if (!args) SWIG_fail;
29313 swig_obj[0] = args;
29314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29315 if (!SWIG_IsOK(res1)) {
29316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29317 }
29318 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29319 {
29320 PyThreadState* __tstate = wxPyBeginAllowThreads();
29321 delete_wxVisualAttributes(arg1);
29322
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 resultobj = SWIG_Py_Void();
29327 return resultobj;
29328 fail:
29329 return NULL;
29330 }
29331
29332
29333 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29334 PyObject *resultobj = 0;
29335 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29336 wxFont *arg2 = (wxFont *) 0 ;
29337 void *argp1 = 0 ;
29338 int res1 = 0 ;
29339 void *argp2 = 0 ;
29340 int res2 = 0 ;
29341 PyObject *swig_obj[2] ;
29342
29343 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29347 }
29348 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29349 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29350 if (!SWIG_IsOK(res2)) {
29351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29352 }
29353 arg2 = reinterpret_cast< wxFont * >(argp2);
29354 if (arg1) (arg1)->font = *arg2;
29355
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 PyObject *resultobj = 0;
29365 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29366 wxFont *result = 0 ;
29367 void *argp1 = 0 ;
29368 int res1 = 0 ;
29369 PyObject *swig_obj[1] ;
29370
29371 if (!args) SWIG_fail;
29372 swig_obj[0] = args;
29373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29374 if (!SWIG_IsOK(res1)) {
29375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29376 }
29377 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29378 result = (wxFont *)& ((arg1)->font);
29379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29387 PyObject *resultobj = 0;
29388 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29389 wxColour *arg2 = (wxColour *) 0 ;
29390 void *argp1 = 0 ;
29391 int res1 = 0 ;
29392 void *argp2 = 0 ;
29393 int res2 = 0 ;
29394 PyObject *swig_obj[2] ;
29395
29396 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29400 }
29401 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29403 if (!SWIG_IsOK(res2)) {
29404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29405 }
29406 arg2 = reinterpret_cast< wxColour * >(argp2);
29407 if (arg1) (arg1)->colFg = *arg2;
29408
29409 resultobj = SWIG_Py_Void();
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29419 wxColour *result = 0 ;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29429 }
29430 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29431 result = (wxColour *)& ((arg1)->colFg);
29432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29440 PyObject *resultobj = 0;
29441 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29442 wxColour *arg2 = (wxColour *) 0 ;
29443 void *argp1 = 0 ;
29444 int res1 = 0 ;
29445 void *argp2 = 0 ;
29446 int res2 = 0 ;
29447 PyObject *swig_obj[2] ;
29448
29449 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29451 if (!SWIG_IsOK(res1)) {
29452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29453 }
29454 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29455 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29456 if (!SWIG_IsOK(res2)) {
29457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29458 }
29459 arg2 = reinterpret_cast< wxColour * >(argp2);
29460 if (arg1) (arg1)->colBg = *arg2;
29461
29462 resultobj = SWIG_Py_Void();
29463 return resultobj;
29464 fail:
29465 return NULL;
29466 }
29467
29468
29469 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29470 PyObject *resultobj = 0;
29471 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29472 wxColour *result = 0 ;
29473 void *argp1 = 0 ;
29474 int res1 = 0 ;
29475 PyObject *swig_obj[1] ;
29476
29477 if (!args) SWIG_fail;
29478 swig_obj[0] = args;
29479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29480 if (!SWIG_IsOK(res1)) {
29481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29482 }
29483 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29484 result = (wxColour *)& ((arg1)->colBg);
29485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29493 PyObject *obj;
29494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29495 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29496 return SWIG_Py_Void();
29497 }
29498
29499 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29500 return SWIG_Python_InitShadowInstance(args);
29501 }
29502
29503 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29504 PyObject *resultobj = 0;
29505 wxWindow *arg1 = (wxWindow *) 0 ;
29506 int arg2 = (int) (int)-1 ;
29507 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29508 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29509 wxSize const &arg4_defvalue = wxDefaultSize ;
29510 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29511 long arg5 = (long) 0 ;
29512 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29513 wxString *arg6 = (wxString *) &arg6_defvalue ;
29514 wxWindow *result = 0 ;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 int val2 ;
29518 int ecode2 = 0 ;
29519 wxPoint temp3 ;
29520 wxSize temp4 ;
29521 long val5 ;
29522 int ecode5 = 0 ;
29523 bool temp6 = false ;
29524 PyObject * obj0 = 0 ;
29525 PyObject * obj1 = 0 ;
29526 PyObject * obj2 = 0 ;
29527 PyObject * obj3 = 0 ;
29528 PyObject * obj4 = 0 ;
29529 PyObject * obj5 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29536 if (!SWIG_IsOK(res1)) {
29537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29538 }
29539 arg1 = reinterpret_cast< wxWindow * >(argp1);
29540 if (obj1) {
29541 ecode2 = SWIG_AsVal_int(obj1, &val2);
29542 if (!SWIG_IsOK(ecode2)) {
29543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29544 }
29545 arg2 = static_cast< int >(val2);
29546 }
29547 if (obj2) {
29548 {
29549 arg3 = &temp3;
29550 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29551 }
29552 }
29553 if (obj3) {
29554 {
29555 arg4 = &temp4;
29556 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29557 }
29558 }
29559 if (obj4) {
29560 ecode5 = SWIG_AsVal_long(obj4, &val5);
29561 if (!SWIG_IsOK(ecode5)) {
29562 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29563 }
29564 arg5 = static_cast< long >(val5);
29565 }
29566 if (obj5) {
29567 {
29568 arg6 = wxString_in_helper(obj5);
29569 if (arg6 == NULL) SWIG_fail;
29570 temp6 = true;
29571 }
29572 }
29573 {
29574 if (!wxPyCheckForApp()) SWIG_fail;
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29581 {
29582 if (temp6)
29583 delete arg6;
29584 }
29585 return resultobj;
29586 fail:
29587 {
29588 if (temp6)
29589 delete arg6;
29590 }
29591 return NULL;
29592 }
29593
29594
29595 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29596 PyObject *resultobj = 0;
29597 wxWindow *result = 0 ;
29598
29599 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29600 {
29601 if (!wxPyCheckForApp()) SWIG_fail;
29602 PyThreadState* __tstate = wxPyBeginAllowThreads();
29603 result = (wxWindow *)new wxWindow();
29604 wxPyEndAllowThreads(__tstate);
29605 if (PyErr_Occurred()) SWIG_fail;
29606 }
29607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj = 0;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 wxWindow *arg2 = (wxWindow *) 0 ;
29618 int arg3 = (int) (int)-1 ;
29619 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29620 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29621 wxSize const &arg5_defvalue = wxDefaultSize ;
29622 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29623 long arg6 = (long) 0 ;
29624 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29625 wxString *arg7 = (wxString *) &arg7_defvalue ;
29626 bool result;
29627 void *argp1 = 0 ;
29628 int res1 = 0 ;
29629 void *argp2 = 0 ;
29630 int res2 = 0 ;
29631 int val3 ;
29632 int ecode3 = 0 ;
29633 wxPoint temp4 ;
29634 wxSize temp5 ;
29635 long val6 ;
29636 int ecode6 = 0 ;
29637 bool temp7 = false ;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 PyObject * obj2 = 0 ;
29641 PyObject * obj3 = 0 ;
29642 PyObject * obj4 = 0 ;
29643 PyObject * obj5 = 0 ;
29644 PyObject * obj6 = 0 ;
29645 char * kwnames[] = {
29646 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29647 };
29648
29649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29653 }
29654 arg1 = reinterpret_cast< wxWindow * >(argp1);
29655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29656 if (!SWIG_IsOK(res2)) {
29657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29658 }
29659 arg2 = reinterpret_cast< wxWindow * >(argp2);
29660 if (obj2) {
29661 ecode3 = SWIG_AsVal_int(obj2, &val3);
29662 if (!SWIG_IsOK(ecode3)) {
29663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29664 }
29665 arg3 = static_cast< int >(val3);
29666 }
29667 if (obj3) {
29668 {
29669 arg4 = &temp4;
29670 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29671 }
29672 }
29673 if (obj4) {
29674 {
29675 arg5 = &temp5;
29676 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29677 }
29678 }
29679 if (obj5) {
29680 ecode6 = SWIG_AsVal_long(obj5, &val6);
29681 if (!SWIG_IsOK(ecode6)) {
29682 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29683 }
29684 arg6 = static_cast< long >(val6);
29685 }
29686 if (obj6) {
29687 {
29688 arg7 = wxString_in_helper(obj6);
29689 if (arg7 == NULL) SWIG_fail;
29690 temp7 = true;
29691 }
29692 }
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29696 wxPyEndAllowThreads(__tstate);
29697 if (PyErr_Occurred()) SWIG_fail;
29698 }
29699 {
29700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29701 }
29702 {
29703 if (temp7)
29704 delete arg7;
29705 }
29706 return resultobj;
29707 fail:
29708 {
29709 if (temp7)
29710 delete arg7;
29711 }
29712 return NULL;
29713 }
29714
29715
29716 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj = 0;
29718 wxWindow *arg1 = (wxWindow *) 0 ;
29719 bool arg2 = (bool) false ;
29720 bool result;
29721 void *argp1 = 0 ;
29722 int res1 = 0 ;
29723 bool val2 ;
29724 int ecode2 = 0 ;
29725 PyObject * obj0 = 0 ;
29726 PyObject * obj1 = 0 ;
29727 char * kwnames[] = {
29728 (char *) "self",(char *) "force", NULL
29729 };
29730
29731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29733 if (!SWIG_IsOK(res1)) {
29734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29735 }
29736 arg1 = reinterpret_cast< wxWindow * >(argp1);
29737 if (obj1) {
29738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29739 if (!SWIG_IsOK(ecode2)) {
29740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29741 }
29742 arg2 = static_cast< bool >(val2);
29743 }
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 result = (bool)(arg1)->Close(arg2);
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 {
29751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29752 }
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29760 PyObject *resultobj = 0;
29761 wxWindow *arg1 = (wxWindow *) 0 ;
29762 bool result;
29763 void *argp1 = 0 ;
29764 int res1 = 0 ;
29765 PyObject *swig_obj[1] ;
29766
29767 if (!args) SWIG_fail;
29768 swig_obj[0] = args;
29769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29770 if (!SWIG_IsOK(res1)) {
29771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29772 }
29773 arg1 = reinterpret_cast< wxWindow * >(argp1);
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (bool)(arg1)->Destroy();
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 {
29781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29782 }
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29790 PyObject *resultobj = 0;
29791 wxWindow *arg1 = (wxWindow *) 0 ;
29792 bool result;
29793 void *argp1 = 0 ;
29794 int res1 = 0 ;
29795 PyObject *swig_obj[1] ;
29796
29797 if (!args) SWIG_fail;
29798 swig_obj[0] = args;
29799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29802 }
29803 arg1 = reinterpret_cast< wxWindow * >(argp1);
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)(arg1)->DestroyChildren();
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 PyObject *resultobj = 0;
29821 wxWindow *arg1 = (wxWindow *) 0 ;
29822 bool result;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 PyObject *swig_obj[1] ;
29826
29827 if (!args) SWIG_fail;
29828 swig_obj[0] = args;
29829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29832 }
29833 arg1 = reinterpret_cast< wxWindow * >(argp1);
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29842 }
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj = 0;
29851 wxWindow *arg1 = (wxWindow *) 0 ;
29852 wxString *arg2 = 0 ;
29853 void *argp1 = 0 ;
29854 int res1 = 0 ;
29855 bool temp2 = false ;
29856 PyObject * obj0 = 0 ;
29857 PyObject * obj1 = 0 ;
29858 char * kwnames[] = {
29859 (char *) "self",(char *) "label", NULL
29860 };
29861
29862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29866 }
29867 arg1 = reinterpret_cast< wxWindow * >(argp1);
29868 {
29869 arg2 = wxString_in_helper(obj1);
29870 if (arg2 == NULL) SWIG_fail;
29871 temp2 = true;
29872 }
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 (arg1)->SetLabel((wxString const &)*arg2);
29876 wxPyEndAllowThreads(__tstate);
29877 if (PyErr_Occurred()) SWIG_fail;
29878 }
29879 resultobj = SWIG_Py_Void();
29880 {
29881 if (temp2)
29882 delete arg2;
29883 }
29884 return resultobj;
29885 fail:
29886 {
29887 if (temp2)
29888 delete arg2;
29889 }
29890 return NULL;
29891 }
29892
29893
29894 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29895 PyObject *resultobj = 0;
29896 wxWindow *arg1 = (wxWindow *) 0 ;
29897 wxString result;
29898 void *argp1 = 0 ;
29899 int res1 = 0 ;
29900 PyObject *swig_obj[1] ;
29901
29902 if (!args) SWIG_fail;
29903 swig_obj[0] = args;
29904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29905 if (!SWIG_IsOK(res1)) {
29906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29907 }
29908 arg1 = reinterpret_cast< wxWindow * >(argp1);
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = ((wxWindow const *)arg1)->GetLabel();
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 #if wxUSE_UNICODE
29917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29918 #else
29919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29920 #endif
29921 }
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29929 PyObject *resultobj = 0;
29930 wxWindow *arg1 = (wxWindow *) 0 ;
29931 wxString *arg2 = 0 ;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 bool temp2 = false ;
29935 PyObject * obj0 = 0 ;
29936 PyObject * obj1 = 0 ;
29937 char * kwnames[] = {
29938 (char *) "self",(char *) "name", NULL
29939 };
29940
29941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29943 if (!SWIG_IsOK(res1)) {
29944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29945 }
29946 arg1 = reinterpret_cast< wxWindow * >(argp1);
29947 {
29948 arg2 = wxString_in_helper(obj1);
29949 if (arg2 == NULL) SWIG_fail;
29950 temp2 = true;
29951 }
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->SetName((wxString const &)*arg2);
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_Py_Void();
29959 {
29960 if (temp2)
29961 delete arg2;
29962 }
29963 return resultobj;
29964 fail:
29965 {
29966 if (temp2)
29967 delete arg2;
29968 }
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxWindow *arg1 = (wxWindow *) 0 ;
29976 wxString result;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29986 }
29987 arg1 = reinterpret_cast< wxWindow * >(argp1);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = ((wxWindow const *)arg1)->GetName();
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 {
29995 #if wxUSE_UNICODE
29996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29997 #else
29998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29999 #endif
30000 }
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 wxWindowVariant arg2 ;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 int val2 ;
30014 int ecode2 = 0 ;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char * kwnames[] = {
30018 (char *) "self",(char *) "variant", NULL
30019 };
30020
30021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30023 if (!SWIG_IsOK(res1)) {
30024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30025 }
30026 arg1 = reinterpret_cast< wxWindow * >(argp1);
30027 ecode2 = SWIG_AsVal_int(obj1, &val2);
30028 if (!SWIG_IsOK(ecode2)) {
30029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30030 }
30031 arg2 = static_cast< wxWindowVariant >(val2);
30032 {
30033 PyThreadState* __tstate = wxPyBeginAllowThreads();
30034 (arg1)->SetWindowVariant(arg2);
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 resultobj = SWIG_Py_Void();
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046 PyObject *resultobj = 0;
30047 wxWindow *arg1 = (wxWindow *) 0 ;
30048 wxWindowVariant result;
30049 void *argp1 = 0 ;
30050 int res1 = 0 ;
30051 PyObject *swig_obj[1] ;
30052
30053 if (!args) SWIG_fail;
30054 swig_obj[0] = args;
30055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30056 if (!SWIG_IsOK(res1)) {
30057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30058 }
30059 arg1 = reinterpret_cast< wxWindow * >(argp1);
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 resultobj = SWIG_From_int(static_cast< int >(result));
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj = 0;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 int arg2 ;
30077 void *argp1 = 0 ;
30078 int res1 = 0 ;
30079 int val2 ;
30080 int ecode2 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 PyObject * obj1 = 0 ;
30083 char * kwnames[] = {
30084 (char *) "self",(char *) "winid", NULL
30085 };
30086
30087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30089 if (!SWIG_IsOK(res1)) {
30090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30091 }
30092 arg1 = reinterpret_cast< wxWindow * >(argp1);
30093 ecode2 = SWIG_AsVal_int(obj1, &val2);
30094 if (!SWIG_IsOK(ecode2)) {
30095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30096 }
30097 arg2 = static_cast< int >(val2);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 (arg1)->SetId(arg2);
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_Py_Void();
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxWindow *arg1 = (wxWindow *) 0 ;
30114 int result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 PyObject *swig_obj[1] ;
30118
30119 if (!args) SWIG_fail;
30120 swig_obj[0] = args;
30121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30122 if (!SWIG_IsOK(res1)) {
30123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30124 }
30125 arg1 = reinterpret_cast< wxWindow * >(argp1);
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (int)((wxWindow const *)arg1)->GetId();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_int(static_cast< int >(result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30140 PyObject *resultobj = 0;
30141 int result;
30142
30143 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 result = (int)wxWindow::NewControlId();
30147 wxPyEndAllowThreads(__tstate);
30148 if (PyErr_Occurred()) SWIG_fail;
30149 }
30150 resultobj = SWIG_From_int(static_cast< int >(result));
30151 return resultobj;
30152 fail:
30153 return NULL;
30154 }
30155
30156
30157 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30158 PyObject *resultobj = 0;
30159 int arg1 ;
30160 int result;
30161 int val1 ;
30162 int ecode1 = 0 ;
30163 PyObject * obj0 = 0 ;
30164 char * kwnames[] = {
30165 (char *) "winid", NULL
30166 };
30167
30168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30169 ecode1 = SWIG_AsVal_int(obj0, &val1);
30170 if (!SWIG_IsOK(ecode1)) {
30171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30172 }
30173 arg1 = static_cast< int >(val1);
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = (int)wxWindow::NextControlId(arg1);
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 resultobj = SWIG_From_int(static_cast< int >(result));
30181 return resultobj;
30182 fail:
30183 return NULL;
30184 }
30185
30186
30187 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30188 PyObject *resultobj = 0;
30189 int arg1 ;
30190 int result;
30191 int val1 ;
30192 int ecode1 = 0 ;
30193 PyObject * obj0 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "winid", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30199 ecode1 = SWIG_AsVal_int(obj0, &val1);
30200 if (!SWIG_IsOK(ecode1)) {
30201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30202 }
30203 arg1 = static_cast< int >(val1);
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 result = (int)wxWindow::PrevControlId(arg1);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_From_int(static_cast< int >(result));
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj = 0;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 wxSize *arg2 = 0 ;
30221 void *argp1 = 0 ;
30222 int res1 = 0 ;
30223 wxSize temp2 ;
30224 PyObject * obj0 = 0 ;
30225 PyObject * obj1 = 0 ;
30226 char * kwnames[] = {
30227 (char *) "self",(char *) "size", NULL
30228 };
30229
30230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30232 if (!SWIG_IsOK(res1)) {
30233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30234 }
30235 arg1 = reinterpret_cast< wxWindow * >(argp1);
30236 {
30237 arg2 = &temp2;
30238 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30239 }
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 (arg1)->SetSize((wxSize const &)*arg2);
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 resultobj = SWIG_Py_Void();
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj = 0;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 int arg2 ;
30257 int arg3 ;
30258 int arg4 ;
30259 int arg5 ;
30260 int arg6 = (int) wxSIZE_AUTO ;
30261 void *argp1 = 0 ;
30262 int res1 = 0 ;
30263 int val2 ;
30264 int ecode2 = 0 ;
30265 int val3 ;
30266 int ecode3 = 0 ;
30267 int val4 ;
30268 int ecode4 = 0 ;
30269 int val5 ;
30270 int ecode5 = 0 ;
30271 int val6 ;
30272 int ecode6 = 0 ;
30273 PyObject * obj0 = 0 ;
30274 PyObject * obj1 = 0 ;
30275 PyObject * obj2 = 0 ;
30276 PyObject * obj3 = 0 ;
30277 PyObject * obj4 = 0 ;
30278 PyObject * obj5 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30285 if (!SWIG_IsOK(res1)) {
30286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30287 }
30288 arg1 = reinterpret_cast< wxWindow * >(argp1);
30289 ecode2 = SWIG_AsVal_int(obj1, &val2);
30290 if (!SWIG_IsOK(ecode2)) {
30291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30292 }
30293 arg2 = static_cast< int >(val2);
30294 ecode3 = SWIG_AsVal_int(obj2, &val3);
30295 if (!SWIG_IsOK(ecode3)) {
30296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30297 }
30298 arg3 = static_cast< int >(val3);
30299 ecode4 = SWIG_AsVal_int(obj3, &val4);
30300 if (!SWIG_IsOK(ecode4)) {
30301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30302 }
30303 arg4 = static_cast< int >(val4);
30304 ecode5 = SWIG_AsVal_int(obj4, &val5);
30305 if (!SWIG_IsOK(ecode5)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30307 }
30308 arg5 = static_cast< int >(val5);
30309 if (obj5) {
30310 ecode6 = SWIG_AsVal_int(obj5, &val6);
30311 if (!SWIG_IsOK(ecode6)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30313 }
30314 arg6 = static_cast< int >(val6);
30315 }
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 resultobj = SWIG_Py_Void();
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30330 PyObject *resultobj = 0;
30331 wxWindow *arg1 = (wxWindow *) 0 ;
30332 wxRect *arg2 = 0 ;
30333 int arg3 = (int) wxSIZE_AUTO ;
30334 void *argp1 = 0 ;
30335 int res1 = 0 ;
30336 wxRect temp2 ;
30337 int val3 ;
30338 int ecode3 = 0 ;
30339 PyObject * obj0 = 0 ;
30340 PyObject * obj1 = 0 ;
30341 PyObject * obj2 = 0 ;
30342 char * kwnames[] = {
30343 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30344 };
30345
30346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30350 }
30351 arg1 = reinterpret_cast< wxWindow * >(argp1);
30352 {
30353 arg2 = &temp2;
30354 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30355 }
30356 if (obj2) {
30357 ecode3 = SWIG_AsVal_int(obj2, &val3);
30358 if (!SWIG_IsOK(ecode3)) {
30359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30360 }
30361 arg3 = static_cast< int >(val3);
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_Py_Void();
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj = 0;
30378 wxWindow *arg1 = (wxWindow *) 0 ;
30379 int arg2 ;
30380 int arg3 ;
30381 void *argp1 = 0 ;
30382 int res1 = 0 ;
30383 int val2 ;
30384 int ecode2 = 0 ;
30385 int val3 ;
30386 int ecode3 = 0 ;
30387 PyObject * obj0 = 0 ;
30388 PyObject * obj1 = 0 ;
30389 PyObject * obj2 = 0 ;
30390 char * kwnames[] = {
30391 (char *) "self",(char *) "width",(char *) "height", NULL
30392 };
30393
30394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30398 }
30399 arg1 = reinterpret_cast< wxWindow * >(argp1);
30400 ecode2 = SWIG_AsVal_int(obj1, &val2);
30401 if (!SWIG_IsOK(ecode2)) {
30402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30403 }
30404 arg2 = static_cast< int >(val2);
30405 ecode3 = SWIG_AsVal_int(obj2, &val3);
30406 if (!SWIG_IsOK(ecode3)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30408 }
30409 arg3 = static_cast< int >(val3);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 (arg1)->SetSize(arg2,arg3);
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 resultobj = SWIG_Py_Void();
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj = 0;
30425 wxWindow *arg1 = (wxWindow *) 0 ;
30426 wxPoint *arg2 = 0 ;
30427 int arg3 = (int) wxSIZE_USE_EXISTING ;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 wxPoint temp2 ;
30431 int val3 ;
30432 int ecode3 = 0 ;
30433 PyObject * obj0 = 0 ;
30434 PyObject * obj1 = 0 ;
30435 PyObject * obj2 = 0 ;
30436 char * kwnames[] = {
30437 (char *) "self",(char *) "pt",(char *) "flags", NULL
30438 };
30439
30440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30442 if (!SWIG_IsOK(res1)) {
30443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30444 }
30445 arg1 = reinterpret_cast< wxWindow * >(argp1);
30446 {
30447 arg2 = &temp2;
30448 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30449 }
30450 if (obj2) {
30451 ecode3 = SWIG_AsVal_int(obj2, &val3);
30452 if (!SWIG_IsOK(ecode3)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30454 }
30455 arg3 = static_cast< int >(val3);
30456 }
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 (arg1)->Move((wxPoint const &)*arg2,arg3);
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 resultobj = SWIG_Py_Void();
30464 return resultobj;
30465 fail:
30466 return NULL;
30467 }
30468
30469
30470 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30471 PyObject *resultobj = 0;
30472 wxWindow *arg1 = (wxWindow *) 0 ;
30473 int arg2 ;
30474 int arg3 ;
30475 int arg4 = (int) wxSIZE_USE_EXISTING ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 int val2 ;
30479 int ecode2 = 0 ;
30480 int val3 ;
30481 int ecode3 = 0 ;
30482 int val4 ;
30483 int ecode4 = 0 ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 PyObject * obj2 = 0 ;
30487 PyObject * obj3 = 0 ;
30488 char * kwnames[] = {
30489 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30490 };
30491
30492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30496 }
30497 arg1 = reinterpret_cast< wxWindow * >(argp1);
30498 ecode2 = SWIG_AsVal_int(obj1, &val2);
30499 if (!SWIG_IsOK(ecode2)) {
30500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30501 }
30502 arg2 = static_cast< int >(val2);
30503 ecode3 = SWIG_AsVal_int(obj2, &val3);
30504 if (!SWIG_IsOK(ecode3)) {
30505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30506 }
30507 arg3 = static_cast< int >(val3);
30508 if (obj3) {
30509 ecode4 = SWIG_AsVal_int(obj3, &val4);
30510 if (!SWIG_IsOK(ecode4)) {
30511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30512 }
30513 arg4 = static_cast< int >(val4);
30514 }
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 (arg1)->Move(arg2,arg3,arg4);
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 resultobj = SWIG_Py_Void();
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = 0;
30530 wxWindow *arg1 = (wxWindow *) 0 ;
30531 wxSize const &arg2_defvalue = wxDefaultSize ;
30532 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 wxSize temp2 ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 char * kwnames[] = {
30539 (char *) "self",(char *) "size", NULL
30540 };
30541
30542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30544 if (!SWIG_IsOK(res1)) {
30545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30546 }
30547 arg1 = reinterpret_cast< wxWindow * >(argp1);
30548 if (obj1) {
30549 {
30550 arg2 = &temp2;
30551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30552 }
30553 }
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 resultobj = SWIG_Py_Void();
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30568 PyObject *resultobj = 0;
30569 wxWindow *arg1 = (wxWindow *) 0 ;
30570 void *argp1 = 0 ;
30571 int res1 = 0 ;
30572 PyObject *swig_obj[1] ;
30573
30574 if (!args) SWIG_fail;
30575 swig_obj[0] = args;
30576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30577 if (!SWIG_IsOK(res1)) {
30578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30579 }
30580 arg1 = reinterpret_cast< wxWindow * >(argp1);
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 (arg1)->Raise();
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 resultobj = SWIG_Py_Void();
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30595 PyObject *resultobj = 0;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 void *argp1 = 0 ;
30598 int res1 = 0 ;
30599 PyObject *swig_obj[1] ;
30600
30601 if (!args) SWIG_fail;
30602 swig_obj[0] = args;
30603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30604 if (!SWIG_IsOK(res1)) {
30605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30606 }
30607 arg1 = reinterpret_cast< wxWindow * >(argp1);
30608 {
30609 PyThreadState* __tstate = wxPyBeginAllowThreads();
30610 (arg1)->Lower();
30611 wxPyEndAllowThreads(__tstate);
30612 if (PyErr_Occurred()) SWIG_fail;
30613 }
30614 resultobj = SWIG_Py_Void();
30615 return resultobj;
30616 fail:
30617 return NULL;
30618 }
30619
30620
30621 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30622 PyObject *resultobj = 0;
30623 wxWindow *arg1 = (wxWindow *) 0 ;
30624 wxSize *arg2 = 0 ;
30625 void *argp1 = 0 ;
30626 int res1 = 0 ;
30627 wxSize temp2 ;
30628 PyObject * obj0 = 0 ;
30629 PyObject * obj1 = 0 ;
30630 char * kwnames[] = {
30631 (char *) "self",(char *) "size", NULL
30632 };
30633
30634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30636 if (!SWIG_IsOK(res1)) {
30637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30638 }
30639 arg1 = reinterpret_cast< wxWindow * >(argp1);
30640 {
30641 arg2 = &temp2;
30642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30643 }
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 (arg1)->SetClientSize((wxSize const &)*arg2);
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_Py_Void();
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj = 0;
30659 wxWindow *arg1 = (wxWindow *) 0 ;
30660 int arg2 ;
30661 int arg3 ;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 int val2 ;
30665 int ecode2 = 0 ;
30666 int val3 ;
30667 int ecode3 = 0 ;
30668 PyObject * obj0 = 0 ;
30669 PyObject * obj1 = 0 ;
30670 PyObject * obj2 = 0 ;
30671 char * kwnames[] = {
30672 (char *) "self",(char *) "width",(char *) "height", NULL
30673 };
30674
30675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30677 if (!SWIG_IsOK(res1)) {
30678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30679 }
30680 arg1 = reinterpret_cast< wxWindow * >(argp1);
30681 ecode2 = SWIG_AsVal_int(obj1, &val2);
30682 if (!SWIG_IsOK(ecode2)) {
30683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30684 }
30685 arg2 = static_cast< int >(val2);
30686 ecode3 = SWIG_AsVal_int(obj2, &val3);
30687 if (!SWIG_IsOK(ecode3)) {
30688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30689 }
30690 arg3 = static_cast< int >(val3);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 (arg1)->SetClientSize(arg2,arg3);
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 wxRect *arg2 = 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 wxRect temp2 ;
30711 PyObject * obj0 = 0 ;
30712 PyObject * obj1 = 0 ;
30713 char * kwnames[] = {
30714 (char *) "self",(char *) "rect", NULL
30715 };
30716
30717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30719 if (!SWIG_IsOK(res1)) {
30720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30721 }
30722 arg1 = reinterpret_cast< wxWindow * >(argp1);
30723 {
30724 arg2 = &temp2;
30725 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30726 }
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 (arg1)->SetClientSize((wxRect const &)*arg2);
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_Py_Void();
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30741 PyObject *resultobj = 0;
30742 wxWindow *arg1 = (wxWindow *) 0 ;
30743 wxPoint result;
30744 void *argp1 = 0 ;
30745 int res1 = 0 ;
30746 PyObject *swig_obj[1] ;
30747
30748 if (!args) SWIG_fail;
30749 swig_obj[0] = args;
30750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30751 if (!SWIG_IsOK(res1)) {
30752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30753 }
30754 arg1 = reinterpret_cast< wxWindow * >(argp1);
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 result = ((wxWindow const *)arg1)->GetPosition();
30758 wxPyEndAllowThreads(__tstate);
30759 if (PyErr_Occurred()) SWIG_fail;
30760 }
30761 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30762 return resultobj;
30763 fail:
30764 return NULL;
30765 }
30766
30767
30768 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30769 PyObject *resultobj = 0;
30770 wxWindow *arg1 = (wxWindow *) 0 ;
30771 int *arg2 = (int *) 0 ;
30772 int *arg3 = (int *) 0 ;
30773 void *argp1 = 0 ;
30774 int res1 = 0 ;
30775 int temp2 ;
30776 int res2 = SWIG_TMPOBJ ;
30777 int temp3 ;
30778 int res3 = SWIG_TMPOBJ ;
30779 PyObject *swig_obj[1] ;
30780
30781 arg2 = &temp2;
30782 arg3 = &temp3;
30783 if (!args) SWIG_fail;
30784 swig_obj[0] = args;
30785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30786 if (!SWIG_IsOK(res1)) {
30787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30788 }
30789 arg1 = reinterpret_cast< wxWindow * >(argp1);
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 resultobj = SWIG_Py_Void();
30797 if (SWIG_IsTmpObj(res2)) {
30798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30799 } else {
30800 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30802 }
30803 if (SWIG_IsTmpObj(res3)) {
30804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30805 } else {
30806 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30808 }
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30816 PyObject *resultobj = 0;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxPoint result;
30819 void *argp1 = 0 ;
30820 int res1 = 0 ;
30821 PyObject *swig_obj[1] ;
30822
30823 if (!args) SWIG_fail;
30824 swig_obj[0] = args;
30825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30828 }
30829 arg1 = reinterpret_cast< wxWindow * >(argp1);
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = ((wxWindow const *)arg1)->GetScreenPosition();
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30844 PyObject *resultobj = 0;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 int *arg2 = (int *) 0 ;
30847 int *arg3 = (int *) 0 ;
30848 void *argp1 = 0 ;
30849 int res1 = 0 ;
30850 int temp2 ;
30851 int res2 = SWIG_TMPOBJ ;
30852 int temp3 ;
30853 int res3 = SWIG_TMPOBJ ;
30854 PyObject *swig_obj[1] ;
30855
30856 arg2 = &temp2;
30857 arg3 = &temp3;
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 resultobj = SWIG_Py_Void();
30872 if (SWIG_IsTmpObj(res2)) {
30873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30874 } else {
30875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30877 }
30878 if (SWIG_IsTmpObj(res3)) {
30879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30880 } else {
30881 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30883 }
30884 return resultobj;
30885 fail:
30886 return NULL;
30887 }
30888
30889
30890 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30891 PyObject *resultobj = 0;
30892 wxWindow *arg1 = (wxWindow *) 0 ;
30893 wxRect result;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 PyObject *swig_obj[1] ;
30897
30898 if (!args) SWIG_fail;
30899 swig_obj[0] = args;
30900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30903 }
30904 arg1 = reinterpret_cast< wxWindow * >(argp1);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = ((wxWindow const *)arg1)->GetScreenRect();
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30919 PyObject *resultobj = 0;
30920 wxWindow *arg1 = (wxWindow *) 0 ;
30921 wxSize result;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 PyObject *swig_obj[1] ;
30925
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = ((wxWindow const *)arg1)->GetSize();
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30940 return resultobj;
30941 fail:
30942 return NULL;
30943 }
30944
30945
30946 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30947 PyObject *resultobj = 0;
30948 wxWindow *arg1 = (wxWindow *) 0 ;
30949 int *arg2 = (int *) 0 ;
30950 int *arg3 = (int *) 0 ;
30951 void *argp1 = 0 ;
30952 int res1 = 0 ;
30953 int temp2 ;
30954 int res2 = SWIG_TMPOBJ ;
30955 int temp3 ;
30956 int res3 = SWIG_TMPOBJ ;
30957 PyObject *swig_obj[1] ;
30958
30959 arg2 = &temp2;
30960 arg3 = &temp3;
30961 if (!args) SWIG_fail;
30962 swig_obj[0] = args;
30963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30966 }
30967 arg1 = reinterpret_cast< wxWindow * >(argp1);
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 resultobj = SWIG_Py_Void();
30975 if (SWIG_IsTmpObj(res2)) {
30976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30977 } else {
30978 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30980 }
30981 if (SWIG_IsTmpObj(res3)) {
30982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30983 } else {
30984 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30994 PyObject *resultobj = 0;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 wxRect result;
30997 void *argp1 = 0 ;
30998 int res1 = 0 ;
30999 PyObject *swig_obj[1] ;
31000
31001 if (!args) SWIG_fail;
31002 swig_obj[0] = args;
31003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31004 if (!SWIG_IsOK(res1)) {
31005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31006 }
31007 arg1 = reinterpret_cast< wxWindow * >(argp1);
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 result = ((wxWindow const *)arg1)->GetRect();
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *resultobj = 0;
31023 wxWindow *arg1 = (wxWindow *) 0 ;
31024 wxSize result;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 PyObject *swig_obj[1] ;
31028
31029 if (!args) SWIG_fail;
31030 swig_obj[0] = args;
31031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31034 }
31035 arg1 = reinterpret_cast< wxWindow * >(argp1);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 result = ((wxWindow const *)arg1)->GetClientSize();
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31050 PyObject *resultobj = 0;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 int *arg2 = (int *) 0 ;
31053 int *arg3 = (int *) 0 ;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 int temp2 ;
31057 int res2 = SWIG_TMPOBJ ;
31058 int temp3 ;
31059 int res3 = SWIG_TMPOBJ ;
31060 PyObject *swig_obj[1] ;
31061
31062 arg2 = &temp2;
31063 arg3 = &temp3;
31064 if (!args) SWIG_fail;
31065 swig_obj[0] = args;
31066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31069 }
31070 arg1 = reinterpret_cast< wxWindow * >(argp1);
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_Py_Void();
31078 if (SWIG_IsTmpObj(res2)) {
31079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31080 } else {
31081 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31083 }
31084 if (SWIG_IsTmpObj(res3)) {
31085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31086 } else {
31087 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31089 }
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31097 PyObject *resultobj = 0;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 wxPoint result;
31100 void *argp1 = 0 ;
31101 int res1 = 0 ;
31102 PyObject *swig_obj[1] ;
31103
31104 if (!args) SWIG_fail;
31105 swig_obj[0] = args;
31106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31107 if (!SWIG_IsOK(res1)) {
31108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31109 }
31110 arg1 = reinterpret_cast< wxWindow * >(argp1);
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31118 return resultobj;
31119 fail:
31120 return NULL;
31121 }
31122
31123
31124 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31125 PyObject *resultobj = 0;
31126 wxWindow *arg1 = (wxWindow *) 0 ;
31127 wxRect result;
31128 void *argp1 = 0 ;
31129 int res1 = 0 ;
31130 PyObject *swig_obj[1] ;
31131
31132 if (!args) SWIG_fail;
31133 swig_obj[0] = args;
31134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31135 if (!SWIG_IsOK(res1)) {
31136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31137 }
31138 arg1 = reinterpret_cast< wxWindow * >(argp1);
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 result = ((wxWindow const *)arg1)->GetClientRect();
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31153 PyObject *resultobj = 0;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxSize result;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 PyObject *swig_obj[1] ;
31159
31160 if (!args) SWIG_fail;
31161 swig_obj[0] = args;
31162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31163 if (!SWIG_IsOK(res1)) {
31164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31165 }
31166 arg1 = reinterpret_cast< wxWindow * >(argp1);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxWindow const *)arg1)->GetBestSize();
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31181 PyObject *resultobj = 0;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 int *arg2 = (int *) 0 ;
31184 int *arg3 = (int *) 0 ;
31185 void *argp1 = 0 ;
31186 int res1 = 0 ;
31187 int temp2 ;
31188 int res2 = SWIG_TMPOBJ ;
31189 int temp3 ;
31190 int res3 = SWIG_TMPOBJ ;
31191 PyObject *swig_obj[1] ;
31192
31193 arg2 = &temp2;
31194 arg3 = &temp3;
31195 if (!args) SWIG_fail;
31196 swig_obj[0] = args;
31197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31198 if (!SWIG_IsOK(res1)) {
31199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31200 }
31201 arg1 = reinterpret_cast< wxWindow * >(argp1);
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 resultobj = SWIG_Py_Void();
31209 if (SWIG_IsTmpObj(res2)) {
31210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31211 } else {
31212 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31214 }
31215 if (SWIG_IsTmpObj(res3)) {
31216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31217 } else {
31218 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31220 }
31221 return resultobj;
31222 fail:
31223 return NULL;
31224 }
31225
31226
31227 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31228 PyObject *resultobj = 0;
31229 wxWindow *arg1 = (wxWindow *) 0 ;
31230 void *argp1 = 0 ;
31231 int res1 = 0 ;
31232 PyObject *swig_obj[1] ;
31233
31234 if (!args) SWIG_fail;
31235 swig_obj[0] = args;
31236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31237 if (!SWIG_IsOK(res1)) {
31238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31239 }
31240 arg1 = reinterpret_cast< wxWindow * >(argp1);
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 (arg1)->InvalidateBestSize();
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_Py_Void();
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31255 PyObject *resultobj = 0;
31256 wxWindow *arg1 = (wxWindow *) 0 ;
31257 wxSize *arg2 = 0 ;
31258 void *argp1 = 0 ;
31259 int res1 = 0 ;
31260 wxSize temp2 ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 char * kwnames[] = {
31264 (char *) "self",(char *) "size", NULL
31265 };
31266
31267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31269 if (!SWIG_IsOK(res1)) {
31270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31271 }
31272 arg1 = reinterpret_cast< wxWindow * >(argp1);
31273 {
31274 arg2 = &temp2;
31275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31276 }
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_Py_Void();
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 wxSize result;
31294 void *argp1 = 0 ;
31295 int res1 = 0 ;
31296 PyObject *swig_obj[1] ;
31297
31298 if (!args) SWIG_fail;
31299 swig_obj[0] = args;
31300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31301 if (!SWIG_IsOK(res1)) {
31302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31303 }
31304 arg1 = reinterpret_cast< wxWindow * >(argp1);
31305 {
31306 PyThreadState* __tstate = wxPyBeginAllowThreads();
31307 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31319 PyObject *resultobj = 0;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 wxSize result;
31322 void *argp1 = 0 ;
31323 int res1 = 0 ;
31324 PyObject *swig_obj[1] ;
31325
31326 if (!args) SWIG_fail;
31327 swig_obj[0] = args;
31328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31331 }
31332 arg1 = reinterpret_cast< wxWindow * >(argp1);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 int arg2 = (int) wxBOTH ;
31350 void *argp1 = 0 ;
31351 int res1 = 0 ;
31352 int val2 ;
31353 int ecode2 = 0 ;
31354 PyObject * obj0 = 0 ;
31355 PyObject * obj1 = 0 ;
31356 char * kwnames[] = {
31357 (char *) "self",(char *) "direction", NULL
31358 };
31359
31360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) 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_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31364 }
31365 arg1 = reinterpret_cast< wxWindow * >(argp1);
31366 if (obj1) {
31367 ecode2 = SWIG_AsVal_int(obj1, &val2);
31368 if (!SWIG_IsOK(ecode2)) {
31369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31370 }
31371 arg2 = static_cast< int >(val2);
31372 }
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 (arg1)->Center(arg2);
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 resultobj = SWIG_Py_Void();
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31387 PyObject *resultobj = 0;
31388 wxWindow *arg1 = (wxWindow *) 0 ;
31389 int arg2 = (int) wxBOTH ;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 int val2 ;
31393 int ecode2 = 0 ;
31394 PyObject * obj0 = 0 ;
31395 PyObject * obj1 = 0 ;
31396 char * kwnames[] = {
31397 (char *) "self",(char *) "dir", NULL
31398 };
31399
31400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31402 if (!SWIG_IsOK(res1)) {
31403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31404 }
31405 arg1 = reinterpret_cast< wxWindow * >(argp1);
31406 if (obj1) {
31407 ecode2 = SWIG_AsVal_int(obj1, &val2);
31408 if (!SWIG_IsOK(ecode2)) {
31409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31410 }
31411 arg2 = static_cast< int >(val2);
31412 }
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 (arg1)->CenterOnParent(arg2);
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 resultobj = SWIG_Py_Void();
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31427 PyObject *resultobj = 0;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 void *argp1 = 0 ;
31430 int res1 = 0 ;
31431 PyObject *swig_obj[1] ;
31432
31433 if (!args) SWIG_fail;
31434 swig_obj[0] = args;
31435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31436 if (!SWIG_IsOK(res1)) {
31437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31438 }
31439 arg1 = reinterpret_cast< wxWindow * >(argp1);
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 (arg1)->Fit();
31443 wxPyEndAllowThreads(__tstate);
31444 if (PyErr_Occurred()) SWIG_fail;
31445 }
31446 resultobj = SWIG_Py_Void();
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *resultobj = 0;
31455 wxWindow *arg1 = (wxWindow *) 0 ;
31456 void *argp1 = 0 ;
31457 int res1 = 0 ;
31458 PyObject *swig_obj[1] ;
31459
31460 if (!args) SWIG_fail;
31461 swig_obj[0] = args;
31462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31463 if (!SWIG_IsOK(res1)) {
31464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31465 }
31466 arg1 = reinterpret_cast< wxWindow * >(argp1);
31467 {
31468 PyThreadState* __tstate = wxPyBeginAllowThreads();
31469 (arg1)->FitInside();
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 resultobj = SWIG_Py_Void();
31474 return resultobj;
31475 fail:
31476 return NULL;
31477 }
31478
31479
31480 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31481 PyObject *resultobj = 0;
31482 wxWindow *arg1 = (wxWindow *) 0 ;
31483 int arg2 ;
31484 int arg3 ;
31485 int arg4 = (int) -1 ;
31486 int arg5 = (int) -1 ;
31487 int arg6 = (int) -1 ;
31488 int arg7 = (int) -1 ;
31489 void *argp1 = 0 ;
31490 int res1 = 0 ;
31491 int val2 ;
31492 int ecode2 = 0 ;
31493 int val3 ;
31494 int ecode3 = 0 ;
31495 int val4 ;
31496 int ecode4 = 0 ;
31497 int val5 ;
31498 int ecode5 = 0 ;
31499 int val6 ;
31500 int ecode6 = 0 ;
31501 int val7 ;
31502 int ecode7 = 0 ;
31503 PyObject * obj0 = 0 ;
31504 PyObject * obj1 = 0 ;
31505 PyObject * obj2 = 0 ;
31506 PyObject * obj3 = 0 ;
31507 PyObject * obj4 = 0 ;
31508 PyObject * obj5 = 0 ;
31509 PyObject * obj6 = 0 ;
31510 char * kwnames[] = {
31511 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31512 };
31513
31514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31516 if (!SWIG_IsOK(res1)) {
31517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31518 }
31519 arg1 = reinterpret_cast< wxWindow * >(argp1);
31520 ecode2 = SWIG_AsVal_int(obj1, &val2);
31521 if (!SWIG_IsOK(ecode2)) {
31522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31523 }
31524 arg2 = static_cast< int >(val2);
31525 ecode3 = SWIG_AsVal_int(obj2, &val3);
31526 if (!SWIG_IsOK(ecode3)) {
31527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31528 }
31529 arg3 = static_cast< int >(val3);
31530 if (obj3) {
31531 ecode4 = SWIG_AsVal_int(obj3, &val4);
31532 if (!SWIG_IsOK(ecode4)) {
31533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31534 }
31535 arg4 = static_cast< int >(val4);
31536 }
31537 if (obj4) {
31538 ecode5 = SWIG_AsVal_int(obj4, &val5);
31539 if (!SWIG_IsOK(ecode5)) {
31540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31541 }
31542 arg5 = static_cast< int >(val5);
31543 }
31544 if (obj5) {
31545 ecode6 = SWIG_AsVal_int(obj5, &val6);
31546 if (!SWIG_IsOK(ecode6)) {
31547 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31548 }
31549 arg6 = static_cast< int >(val6);
31550 }
31551 if (obj6) {
31552 ecode7 = SWIG_AsVal_int(obj6, &val7);
31553 if (!SWIG_IsOK(ecode7)) {
31554 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31555 }
31556 arg7 = static_cast< int >(val7);
31557 }
31558 {
31559 PyThreadState* __tstate = wxPyBeginAllowThreads();
31560 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31561 wxPyEndAllowThreads(__tstate);
31562 if (PyErr_Occurred()) SWIG_fail;
31563 }
31564 resultobj = SWIG_Py_Void();
31565 return resultobj;
31566 fail:
31567 return NULL;
31568 }
31569
31570
31571 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31572 PyObject *resultobj = 0;
31573 wxWindow *arg1 = (wxWindow *) 0 ;
31574 wxSize *arg2 = 0 ;
31575 wxSize const &arg3_defvalue = wxDefaultSize ;
31576 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31577 wxSize const &arg4_defvalue = wxDefaultSize ;
31578 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31579 void *argp1 = 0 ;
31580 int res1 = 0 ;
31581 wxSize temp2 ;
31582 wxSize temp3 ;
31583 wxSize temp4 ;
31584 PyObject * obj0 = 0 ;
31585 PyObject * obj1 = 0 ;
31586 PyObject * obj2 = 0 ;
31587 PyObject * obj3 = 0 ;
31588 char * kwnames[] = {
31589 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31590 };
31591
31592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31594 if (!SWIG_IsOK(res1)) {
31595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31596 }
31597 arg1 = reinterpret_cast< wxWindow * >(argp1);
31598 {
31599 arg2 = &temp2;
31600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31601 }
31602 if (obj2) {
31603 {
31604 arg3 = &temp3;
31605 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31606 }
31607 }
31608 if (obj3) {
31609 {
31610 arg4 = &temp4;
31611 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31612 }
31613 }
31614 {
31615 PyThreadState* __tstate = wxPyBeginAllowThreads();
31616 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31617 wxPyEndAllowThreads(__tstate);
31618 if (PyErr_Occurred()) SWIG_fail;
31619 }
31620 resultobj = SWIG_Py_Void();
31621 return resultobj;
31622 fail:
31623 return NULL;
31624 }
31625
31626
31627 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31628 PyObject *resultobj = 0;
31629 wxWindow *arg1 = (wxWindow *) 0 ;
31630 int arg2 ;
31631 int arg3 ;
31632 int arg4 = (int) -1 ;
31633 int arg5 = (int) -1 ;
31634 void *argp1 = 0 ;
31635 int res1 = 0 ;
31636 int val2 ;
31637 int ecode2 = 0 ;
31638 int val3 ;
31639 int ecode3 = 0 ;
31640 int val4 ;
31641 int ecode4 = 0 ;
31642 int val5 ;
31643 int ecode5 = 0 ;
31644 PyObject * obj0 = 0 ;
31645 PyObject * obj1 = 0 ;
31646 PyObject * obj2 = 0 ;
31647 PyObject * obj3 = 0 ;
31648 PyObject * obj4 = 0 ;
31649 char * kwnames[] = {
31650 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31651 };
31652
31653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31657 }
31658 arg1 = reinterpret_cast< wxWindow * >(argp1);
31659 ecode2 = SWIG_AsVal_int(obj1, &val2);
31660 if (!SWIG_IsOK(ecode2)) {
31661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31662 }
31663 arg2 = static_cast< int >(val2);
31664 ecode3 = SWIG_AsVal_int(obj2, &val3);
31665 if (!SWIG_IsOK(ecode3)) {
31666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31667 }
31668 arg3 = static_cast< int >(val3);
31669 if (obj3) {
31670 ecode4 = SWIG_AsVal_int(obj3, &val4);
31671 if (!SWIG_IsOK(ecode4)) {
31672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31673 }
31674 arg4 = static_cast< int >(val4);
31675 }
31676 if (obj4) {
31677 ecode5 = SWIG_AsVal_int(obj4, &val5);
31678 if (!SWIG_IsOK(ecode5)) {
31679 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31680 }
31681 arg5 = static_cast< int >(val5);
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31697 PyObject *resultobj = 0;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 wxSize *arg2 = 0 ;
31700 wxSize const &arg3_defvalue = wxDefaultSize ;
31701 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31702 void *argp1 = 0 ;
31703 int res1 = 0 ;
31704 wxSize temp2 ;
31705 wxSize temp3 ;
31706 PyObject * obj0 = 0 ;
31707 PyObject * obj1 = 0 ;
31708 PyObject * obj2 = 0 ;
31709 char * kwnames[] = {
31710 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31711 };
31712
31713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31717 }
31718 arg1 = reinterpret_cast< wxWindow * >(argp1);
31719 {
31720 arg2 = &temp2;
31721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31722 }
31723 if (obj2) {
31724 {
31725 arg3 = &temp3;
31726 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31727 }
31728 }
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31732 wxPyEndAllowThreads(__tstate);
31733 if (PyErr_Occurred()) SWIG_fail;
31734 }
31735 resultobj = SWIG_Py_Void();
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31743 PyObject *resultobj = 0;
31744 wxWindow *arg1 = (wxWindow *) 0 ;
31745 wxSize result;
31746 void *argp1 = 0 ;
31747 int res1 = 0 ;
31748 PyObject *swig_obj[1] ;
31749
31750 if (!args) SWIG_fail;
31751 swig_obj[0] = args;
31752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31753 if (!SWIG_IsOK(res1)) {
31754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31755 }
31756 arg1 = reinterpret_cast< wxWindow * >(argp1);
31757 {
31758 PyThreadState* __tstate = wxPyBeginAllowThreads();
31759 result = ((wxWindow const *)arg1)->GetMaxSize();
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31764 return resultobj;
31765 fail:
31766 return NULL;
31767 }
31768
31769
31770 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31771 PyObject *resultobj = 0;
31772 wxWindow *arg1 = (wxWindow *) 0 ;
31773 wxSize result;
31774 void *argp1 = 0 ;
31775 int res1 = 0 ;
31776 PyObject *swig_obj[1] ;
31777
31778 if (!args) SWIG_fail;
31779 swig_obj[0] = args;
31780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31781 if (!SWIG_IsOK(res1)) {
31782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31783 }
31784 arg1 = reinterpret_cast< wxWindow * >(argp1);
31785 {
31786 PyThreadState* __tstate = wxPyBeginAllowThreads();
31787 result = ((wxWindow const *)arg1)->GetMinSize();
31788 wxPyEndAllowThreads(__tstate);
31789 if (PyErr_Occurred()) SWIG_fail;
31790 }
31791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31792 return resultobj;
31793 fail:
31794 return NULL;
31795 }
31796
31797
31798 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31799 PyObject *resultobj = 0;
31800 wxWindow *arg1 = (wxWindow *) 0 ;
31801 wxSize *arg2 = 0 ;
31802 void *argp1 = 0 ;
31803 int res1 = 0 ;
31804 wxSize temp2 ;
31805 PyObject * obj0 = 0 ;
31806 PyObject * obj1 = 0 ;
31807 char * kwnames[] = {
31808 (char *) "self",(char *) "minSize", NULL
31809 };
31810
31811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31813 if (!SWIG_IsOK(res1)) {
31814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31815 }
31816 arg1 = reinterpret_cast< wxWindow * >(argp1);
31817 {
31818 arg2 = &temp2;
31819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31820 }
31821 {
31822 PyThreadState* __tstate = wxPyBeginAllowThreads();
31823 (arg1)->SetMinSize((wxSize const &)*arg2);
31824 wxPyEndAllowThreads(__tstate);
31825 if (PyErr_Occurred()) SWIG_fail;
31826 }
31827 resultobj = SWIG_Py_Void();
31828 return resultobj;
31829 fail:
31830 return NULL;
31831 }
31832
31833
31834 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj = 0;
31836 wxWindow *arg1 = (wxWindow *) 0 ;
31837 wxSize *arg2 = 0 ;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 wxSize temp2 ;
31841 PyObject * obj0 = 0 ;
31842 PyObject * obj1 = 0 ;
31843 char * kwnames[] = {
31844 (char *) "self",(char *) "maxSize", NULL
31845 };
31846
31847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31849 if (!SWIG_IsOK(res1)) {
31850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31851 }
31852 arg1 = reinterpret_cast< wxWindow * >(argp1);
31853 {
31854 arg2 = &temp2;
31855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31856 }
31857 {
31858 PyThreadState* __tstate = wxPyBeginAllowThreads();
31859 (arg1)->SetMaxSize((wxSize const &)*arg2);
31860 wxPyEndAllowThreads(__tstate);
31861 if (PyErr_Occurred()) SWIG_fail;
31862 }
31863 resultobj = SWIG_Py_Void();
31864 return resultobj;
31865 fail:
31866 return NULL;
31867 }
31868
31869
31870 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31871 PyObject *resultobj = 0;
31872 wxWindow *arg1 = (wxWindow *) 0 ;
31873 int result;
31874 void *argp1 = 0 ;
31875 int res1 = 0 ;
31876 PyObject *swig_obj[1] ;
31877
31878 if (!args) SWIG_fail;
31879 swig_obj[0] = args;
31880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31881 if (!SWIG_IsOK(res1)) {
31882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31883 }
31884 arg1 = reinterpret_cast< wxWindow * >(argp1);
31885 {
31886 PyThreadState* __tstate = wxPyBeginAllowThreads();
31887 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 resultobj = SWIG_From_int(static_cast< int >(result));
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31899 PyObject *resultobj = 0;
31900 wxWindow *arg1 = (wxWindow *) 0 ;
31901 int result;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 PyObject *swig_obj[1] ;
31905
31906 if (!args) SWIG_fail;
31907 swig_obj[0] = args;
31908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31911 }
31912 arg1 = reinterpret_cast< wxWindow * >(argp1);
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_From_int(static_cast< int >(result));
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *resultobj = 0;
31928 wxWindow *arg1 = (wxWindow *) 0 ;
31929 int result;
31930 void *argp1 = 0 ;
31931 int res1 = 0 ;
31932 PyObject *swig_obj[1] ;
31933
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31939 }
31940 arg1 = reinterpret_cast< wxWindow * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_From_int(static_cast< int >(result));
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *resultobj = 0;
31956 wxWindow *arg1 = (wxWindow *) 0 ;
31957 int result;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 PyObject *swig_obj[1] ;
31961
31962 if (!args) SWIG_fail;
31963 swig_obj[0] = args;
31964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31967 }
31968 arg1 = reinterpret_cast< wxWindow * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_From_int(static_cast< int >(result));
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 wxSize *arg2 = 0 ;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 wxSize temp2 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 char * kwnames[] = {
31992 (char *) "self",(char *) "size", NULL
31993 };
31994
31995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 {
32002 arg2 = &temp2;
32003 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32004 }
32005 {
32006 PyThreadState* __tstate = wxPyBeginAllowThreads();
32007 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 resultobj = SWIG_Py_Void();
32012 return resultobj;
32013 fail:
32014 return NULL;
32015 }
32016
32017
32018 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32019 PyObject *resultobj = 0;
32020 wxWindow *arg1 = (wxWindow *) 0 ;
32021 int arg2 ;
32022 int arg3 ;
32023 void *argp1 = 0 ;
32024 int res1 = 0 ;
32025 int val2 ;
32026 int ecode2 = 0 ;
32027 int val3 ;
32028 int ecode3 = 0 ;
32029 PyObject * obj0 = 0 ;
32030 PyObject * obj1 = 0 ;
32031 PyObject * obj2 = 0 ;
32032 char * kwnames[] = {
32033 (char *) "self",(char *) "w",(char *) "h", NULL
32034 };
32035
32036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32038 if (!SWIG_IsOK(res1)) {
32039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32040 }
32041 arg1 = reinterpret_cast< wxWindow * >(argp1);
32042 ecode2 = SWIG_AsVal_int(obj1, &val2);
32043 if (!SWIG_IsOK(ecode2)) {
32044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32045 }
32046 arg2 = static_cast< int >(val2);
32047 ecode3 = SWIG_AsVal_int(obj2, &val3);
32048 if (!SWIG_IsOK(ecode3)) {
32049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32050 }
32051 arg3 = static_cast< int >(val3);
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 (arg1)->SetVirtualSize(arg2,arg3);
32055 wxPyEndAllowThreads(__tstate);
32056 if (PyErr_Occurred()) SWIG_fail;
32057 }
32058 resultobj = SWIG_Py_Void();
32059 return resultobj;
32060 fail:
32061 return NULL;
32062 }
32063
32064
32065 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32066 PyObject *resultobj = 0;
32067 wxWindow *arg1 = (wxWindow *) 0 ;
32068 wxSize result;
32069 void *argp1 = 0 ;
32070 int res1 = 0 ;
32071 PyObject *swig_obj[1] ;
32072
32073 if (!args) SWIG_fail;
32074 swig_obj[0] = args;
32075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32076 if (!SWIG_IsOK(res1)) {
32077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32078 }
32079 arg1 = reinterpret_cast< wxWindow * >(argp1);
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = ((wxWindow const *)arg1)->GetVirtualSize();
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 PyObject *resultobj = 0;
32095 wxWindow *arg1 = (wxWindow *) 0 ;
32096 int *arg2 = (int *) 0 ;
32097 int *arg3 = (int *) 0 ;
32098 void *argp1 = 0 ;
32099 int res1 = 0 ;
32100 int temp2 ;
32101 int res2 = SWIG_TMPOBJ ;
32102 int temp3 ;
32103 int res3 = SWIG_TMPOBJ ;
32104 PyObject *swig_obj[1] ;
32105
32106 arg2 = &temp2;
32107 arg3 = &temp3;
32108 if (!args) SWIG_fail;
32109 swig_obj[0] = args;
32110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32113 }
32114 arg1 = reinterpret_cast< wxWindow * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_Py_Void();
32122 if (SWIG_IsTmpObj(res2)) {
32123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32124 } else {
32125 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32127 }
32128 if (SWIG_IsTmpObj(res3)) {
32129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32130 } else {
32131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32133 }
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32141 PyObject *resultobj = 0;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 wxSize result;
32144 void *argp1 = 0 ;
32145 int res1 = 0 ;
32146 PyObject *swig_obj[1] ;
32147
32148 if (!args) SWIG_fail;
32149 swig_obj[0] = args;
32150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32162 return resultobj;
32163 fail:
32164 return NULL;
32165 }
32166
32167
32168 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32169 PyObject *resultobj = 0;
32170 wxWindow *arg1 = (wxWindow *) 0 ;
32171 bool arg2 = (bool) true ;
32172 bool result;
32173 void *argp1 = 0 ;
32174 int res1 = 0 ;
32175 bool val2 ;
32176 int ecode2 = 0 ;
32177 PyObject * obj0 = 0 ;
32178 PyObject * obj1 = 0 ;
32179 char * kwnames[] = {
32180 (char *) "self",(char *) "show", NULL
32181 };
32182
32183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32185 if (!SWIG_IsOK(res1)) {
32186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32187 }
32188 arg1 = reinterpret_cast< wxWindow * >(argp1);
32189 if (obj1) {
32190 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32191 if (!SWIG_IsOK(ecode2)) {
32192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32193 }
32194 arg2 = static_cast< bool >(val2);
32195 }
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 result = (bool)(arg1)->Show(arg2);
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 {
32203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32204 }
32205 return resultobj;
32206 fail:
32207 return NULL;
32208 }
32209
32210
32211 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32212 PyObject *resultobj = 0;
32213 wxWindow *arg1 = (wxWindow *) 0 ;
32214 bool result;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 PyObject *swig_obj[1] ;
32218
32219 if (!args) SWIG_fail;
32220 swig_obj[0] = args;
32221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32224 }
32225 arg1 = reinterpret_cast< wxWindow * >(argp1);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 result = (bool)(arg1)->Hide();
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 {
32233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32234 }
32235 return resultobj;
32236 fail:
32237 return NULL;
32238 }
32239
32240
32241 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32242 PyObject *resultobj = 0;
32243 wxWindow *arg1 = (wxWindow *) 0 ;
32244 bool arg2 = (bool) true ;
32245 bool result;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 bool val2 ;
32249 int ecode2 = 0 ;
32250 PyObject * obj0 = 0 ;
32251 PyObject * obj1 = 0 ;
32252 char * kwnames[] = {
32253 (char *) "self",(char *) "enable", NULL
32254 };
32255
32256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32260 }
32261 arg1 = reinterpret_cast< wxWindow * >(argp1);
32262 if (obj1) {
32263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32264 if (!SWIG_IsOK(ecode2)) {
32265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32266 }
32267 arg2 = static_cast< bool >(val2);
32268 }
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 result = (bool)(arg1)->Enable(arg2);
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 {
32276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32277 }
32278 return resultobj;
32279 fail:
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32285 PyObject *resultobj = 0;
32286 wxWindow *arg1 = (wxWindow *) 0 ;
32287 bool result;
32288 void *argp1 = 0 ;
32289 int res1 = 0 ;
32290 PyObject *swig_obj[1] ;
32291
32292 if (!args) SWIG_fail;
32293 swig_obj[0] = args;
32294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32297 }
32298 arg1 = reinterpret_cast< wxWindow * >(argp1);
32299 {
32300 PyThreadState* __tstate = wxPyBeginAllowThreads();
32301 result = (bool)(arg1)->Disable();
32302 wxPyEndAllowThreads(__tstate);
32303 if (PyErr_Occurred()) SWIG_fail;
32304 }
32305 {
32306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32307 }
32308 return resultobj;
32309 fail:
32310 return NULL;
32311 }
32312
32313
32314 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32315 PyObject *resultobj = 0;
32316 wxWindow *arg1 = (wxWindow *) 0 ;
32317 bool result;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 PyObject *swig_obj[1] ;
32321
32322 if (!args) SWIG_fail;
32323 swig_obj[0] = args;
32324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32325 if (!SWIG_IsOK(res1)) {
32326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32327 }
32328 arg1 = reinterpret_cast< wxWindow * >(argp1);
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (bool)((wxWindow const *)arg1)->IsShown();
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 {
32336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32337 }
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxWindow *arg1 = (wxWindow *) 0 ;
32347 bool result;
32348 void *argp1 = 0 ;
32349 int res1 = 0 ;
32350 PyObject *swig_obj[1] ;
32351
32352 if (!args) SWIG_fail;
32353 swig_obj[0] = args;
32354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32355 if (!SWIG_IsOK(res1)) {
32356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32357 }
32358 arg1 = reinterpret_cast< wxWindow * >(argp1);
32359 {
32360 PyThreadState* __tstate = wxPyBeginAllowThreads();
32361 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj = 0;
32376 wxWindow *arg1 = (wxWindow *) 0 ;
32377 long arg2 ;
32378 void *argp1 = 0 ;
32379 int res1 = 0 ;
32380 long val2 ;
32381 int ecode2 = 0 ;
32382 PyObject * obj0 = 0 ;
32383 PyObject * obj1 = 0 ;
32384 char * kwnames[] = {
32385 (char *) "self",(char *) "style", NULL
32386 };
32387
32388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32392 }
32393 arg1 = reinterpret_cast< wxWindow * >(argp1);
32394 ecode2 = SWIG_AsVal_long(obj1, &val2);
32395 if (!SWIG_IsOK(ecode2)) {
32396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32397 }
32398 arg2 = static_cast< long >(val2);
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 (arg1)->SetWindowStyleFlag(arg2);
32402 wxPyEndAllowThreads(__tstate);
32403 if (PyErr_Occurred()) SWIG_fail;
32404 }
32405 resultobj = SWIG_Py_Void();
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32413 PyObject *resultobj = 0;
32414 wxWindow *arg1 = (wxWindow *) 0 ;
32415 long result;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 PyObject *swig_obj[1] ;
32419
32420 if (!args) SWIG_fail;
32421 swig_obj[0] = args;
32422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32423 if (!SWIG_IsOK(res1)) {
32424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32425 }
32426 arg1 = reinterpret_cast< wxWindow * >(argp1);
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_From_long(static_cast< long >(result));
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 int arg2 ;
32444 bool result;
32445 void *argp1 = 0 ;
32446 int res1 = 0 ;
32447 int val2 ;
32448 int ecode2 = 0 ;
32449 PyObject * obj0 = 0 ;
32450 PyObject * obj1 = 0 ;
32451 char * kwnames[] = {
32452 (char *) "self",(char *) "flag", NULL
32453 };
32454
32455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32457 if (!SWIG_IsOK(res1)) {
32458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32459 }
32460 arg1 = reinterpret_cast< wxWindow * >(argp1);
32461 ecode2 = SWIG_AsVal_int(obj1, &val2);
32462 if (!SWIG_IsOK(ecode2)) {
32463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32464 }
32465 arg2 = static_cast< int >(val2);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 {
32473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32474 }
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 bool result;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32494 }
32495 arg1 = reinterpret_cast< wxWindow * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (bool)((wxWindow const *)arg1)->IsRetained();
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 {
32503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32504 }
32505 return resultobj;
32506 fail:
32507 return NULL;
32508 }
32509
32510
32511 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32512 PyObject *resultobj = 0;
32513 wxWindow *arg1 = (wxWindow *) 0 ;
32514 long arg2 ;
32515 void *argp1 = 0 ;
32516 int res1 = 0 ;
32517 long val2 ;
32518 int ecode2 = 0 ;
32519 PyObject * obj0 = 0 ;
32520 PyObject * obj1 = 0 ;
32521 char * kwnames[] = {
32522 (char *) "self",(char *) "exStyle", NULL
32523 };
32524
32525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32529 }
32530 arg1 = reinterpret_cast< wxWindow * >(argp1);
32531 ecode2 = SWIG_AsVal_long(obj1, &val2);
32532 if (!SWIG_IsOK(ecode2)) {
32533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32534 }
32535 arg2 = static_cast< long >(val2);
32536 {
32537 PyThreadState* __tstate = wxPyBeginAllowThreads();
32538 (arg1)->SetExtraStyle(arg2);
32539 wxPyEndAllowThreads(__tstate);
32540 if (PyErr_Occurred()) SWIG_fail;
32541 }
32542 resultobj = SWIG_Py_Void();
32543 return resultobj;
32544 fail:
32545 return NULL;
32546 }
32547
32548
32549 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32550 PyObject *resultobj = 0;
32551 wxWindow *arg1 = (wxWindow *) 0 ;
32552 long result;
32553 void *argp1 = 0 ;
32554 int res1 = 0 ;
32555 PyObject *swig_obj[1] ;
32556
32557 if (!args) SWIG_fail;
32558 swig_obj[0] = args;
32559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32562 }
32563 arg1 = reinterpret_cast< wxWindow * >(argp1);
32564 {
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 resultobj = SWIG_From_long(static_cast< long >(result));
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32578 PyObject *resultobj = 0;
32579 wxWindow *arg1 = (wxWindow *) 0 ;
32580 bool arg2 = (bool) true ;
32581 void *argp1 = 0 ;
32582 int res1 = 0 ;
32583 bool val2 ;
32584 int ecode2 = 0 ;
32585 PyObject * obj0 = 0 ;
32586 PyObject * obj1 = 0 ;
32587 char * kwnames[] = {
32588 (char *) "self",(char *) "modal", NULL
32589 };
32590
32591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32593 if (!SWIG_IsOK(res1)) {
32594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32595 }
32596 arg1 = reinterpret_cast< wxWindow * >(argp1);
32597 if (obj1) {
32598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32599 if (!SWIG_IsOK(ecode2)) {
32600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32601 }
32602 arg2 = static_cast< bool >(val2);
32603 }
32604 {
32605 PyThreadState* __tstate = wxPyBeginAllowThreads();
32606 (arg1)->MakeModal(arg2);
32607 wxPyEndAllowThreads(__tstate);
32608 if (PyErr_Occurred()) SWIG_fail;
32609 }
32610 resultobj = SWIG_Py_Void();
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj = 0;
32619 wxWindow *arg1 = (wxWindow *) 0 ;
32620 bool arg2 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 bool val2 ;
32624 int ecode2 = 0 ;
32625 PyObject * obj0 = 0 ;
32626 PyObject * obj1 = 0 ;
32627 char * kwnames[] = {
32628 (char *) "self",(char *) "enableTheme", NULL
32629 };
32630
32631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32635 }
32636 arg1 = reinterpret_cast< wxWindow * >(argp1);
32637 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32638 if (!SWIG_IsOK(ecode2)) {
32639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32640 }
32641 arg2 = static_cast< bool >(val2);
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 (arg1)->SetThemeEnabled(arg2);
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 resultobj = SWIG_Py_Void();
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 PyObject *resultobj = 0;
32657 wxWindow *arg1 = (wxWindow *) 0 ;
32658 bool result;
32659 void *argp1 = 0 ;
32660 int res1 = 0 ;
32661 PyObject *swig_obj[1] ;
32662
32663 if (!args) SWIG_fail;
32664 swig_obj[0] = args;
32665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32666 if (!SWIG_IsOK(res1)) {
32667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32668 }
32669 arg1 = reinterpret_cast< wxWindow * >(argp1);
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32673 wxPyEndAllowThreads(__tstate);
32674 if (PyErr_Occurred()) SWIG_fail;
32675 }
32676 {
32677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32678 }
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 void *argp1 = 0 ;
32689 int res1 = 0 ;
32690 PyObject *swig_obj[1] ;
32691
32692 if (!args) SWIG_fail;
32693 swig_obj[0] = args;
32694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32695 if (!SWIG_IsOK(res1)) {
32696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32697 }
32698 arg1 = reinterpret_cast< wxWindow * >(argp1);
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->SetFocus();
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *resultobj = 0;
32714 wxWindow *arg1 = (wxWindow *) 0 ;
32715 void *argp1 = 0 ;
32716 int res1 = 0 ;
32717 PyObject *swig_obj[1] ;
32718
32719 if (!args) SWIG_fail;
32720 swig_obj[0] = args;
32721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32722 if (!SWIG_IsOK(res1)) {
32723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32724 }
32725 arg1 = reinterpret_cast< wxWindow * >(argp1);
32726 {
32727 PyThreadState* __tstate = wxPyBeginAllowThreads();
32728 (arg1)->SetFocusFromKbd();
32729 wxPyEndAllowThreads(__tstate);
32730 if (PyErr_Occurred()) SWIG_fail;
32731 }
32732 resultobj = SWIG_Py_Void();
32733 return resultobj;
32734 fail:
32735 return NULL;
32736 }
32737
32738
32739 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32740 PyObject *resultobj = 0;
32741 wxWindow *result = 0 ;
32742
32743 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32744 {
32745 if (!wxPyCheckForApp()) SWIG_fail;
32746 PyThreadState* __tstate = wxPyBeginAllowThreads();
32747 result = (wxWindow *)wxWindow::FindFocus();
32748 wxPyEndAllowThreads(__tstate);
32749 if (PyErr_Occurred()) SWIG_fail;
32750 }
32751 {
32752 resultobj = wxPyMake_wxObject(result, 0);
32753 }
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32761 PyObject *resultobj = 0;
32762 wxWindow *arg1 = (wxWindow *) 0 ;
32763 bool result;
32764 void *argp1 = 0 ;
32765 int res1 = 0 ;
32766 PyObject *swig_obj[1] ;
32767
32768 if (!args) SWIG_fail;
32769 swig_obj[0] = args;
32770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32771 if (!SWIG_IsOK(res1)) {
32772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32773 }
32774 arg1 = reinterpret_cast< wxWindow * >(argp1);
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 {
32782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32783 }
32784 return resultobj;
32785 fail:
32786 return NULL;
32787 }
32788
32789
32790 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32791 PyObject *resultobj = 0;
32792 wxWindow *arg1 = (wxWindow *) 0 ;
32793 bool result;
32794 void *argp1 = 0 ;
32795 int res1 = 0 ;
32796 PyObject *swig_obj[1] ;
32797
32798 if (!args) SWIG_fail;
32799 swig_obj[0] = args;
32800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32801 if (!SWIG_IsOK(res1)) {
32802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32803 }
32804 arg1 = reinterpret_cast< wxWindow * >(argp1);
32805 {
32806 PyThreadState* __tstate = wxPyBeginAllowThreads();
32807 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32808 wxPyEndAllowThreads(__tstate);
32809 if (PyErr_Occurred()) SWIG_fail;
32810 }
32811 {
32812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32813 }
32814 return resultobj;
32815 fail:
32816 return NULL;
32817 }
32818
32819
32820 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32821 PyObject *resultobj = 0;
32822 wxWindow *arg1 = (wxWindow *) 0 ;
32823 wxWindow *result = 0 ;
32824 void *argp1 = 0 ;
32825 int res1 = 0 ;
32826 PyObject *swig_obj[1] ;
32827
32828 if (!args) SWIG_fail;
32829 swig_obj[0] = args;
32830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32831 if (!SWIG_IsOK(res1)) {
32832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32833 }
32834 arg1 = reinterpret_cast< wxWindow * >(argp1);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 {
32842 resultobj = wxPyMake_wxObject(result, 0);
32843 }
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj = 0;
32852 wxWindow *arg1 = (wxWindow *) 0 ;
32853 wxWindow *arg2 = (wxWindow *) 0 ;
32854 wxWindow *result = 0 ;
32855 void *argp1 = 0 ;
32856 int res1 = 0 ;
32857 void *argp2 = 0 ;
32858 int res2 = 0 ;
32859 PyObject * obj0 = 0 ;
32860 PyObject * obj1 = 0 ;
32861 char * kwnames[] = {
32862 (char *) "self",(char *) "child", NULL
32863 };
32864
32865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32867 if (!SWIG_IsOK(res1)) {
32868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32869 }
32870 arg1 = reinterpret_cast< wxWindow * >(argp1);
32871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32872 if (!SWIG_IsOK(res2)) {
32873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32874 }
32875 arg2 = reinterpret_cast< wxWindow * >(argp2);
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32879 wxPyEndAllowThreads(__tstate);
32880 if (PyErr_Occurred()) SWIG_fail;
32881 }
32882 {
32883 resultobj = wxPyMake_wxObject(result, 0);
32884 }
32885 return resultobj;
32886 fail:
32887 return NULL;
32888 }
32889
32890
32891 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32892 PyObject *resultobj = 0;
32893 wxWindow *arg1 = (wxWindow *) 0 ;
32894 wxWindow *arg2 = (wxWindow *) 0 ;
32895 void *argp1 = 0 ;
32896 int res1 = 0 ;
32897 void *argp2 = 0 ;
32898 int res2 = 0 ;
32899 PyObject * obj0 = 0 ;
32900 PyObject * obj1 = 0 ;
32901 char * kwnames[] = {
32902 (char *) "self",(char *) "win", NULL
32903 };
32904
32905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32907 if (!SWIG_IsOK(res1)) {
32908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32909 }
32910 arg1 = reinterpret_cast< wxWindow * >(argp1);
32911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32912 if (!SWIG_IsOK(res2)) {
32913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32914 }
32915 arg2 = reinterpret_cast< wxWindow * >(argp2);
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 (arg1)->SetTmpDefaultItem(arg2);
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 resultobj = SWIG_Py_Void();
32923 return resultobj;
32924 fail:
32925 return NULL;
32926 }
32927
32928
32929 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32930 PyObject *resultobj = 0;
32931 wxWindow *arg1 = (wxWindow *) 0 ;
32932 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32933 bool result;
32934 void *argp1 = 0 ;
32935 int res1 = 0 ;
32936 int val2 ;
32937 int ecode2 = 0 ;
32938 PyObject * obj0 = 0 ;
32939 PyObject * obj1 = 0 ;
32940 char * kwnames[] = {
32941 (char *) "self",(char *) "flags", NULL
32942 };
32943
32944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32946 if (!SWIG_IsOK(res1)) {
32947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32948 }
32949 arg1 = reinterpret_cast< wxWindow * >(argp1);
32950 if (obj1) {
32951 ecode2 = SWIG_AsVal_int(obj1, &val2);
32952 if (!SWIG_IsOK(ecode2)) {
32953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32954 }
32955 arg2 = static_cast< int >(val2);
32956 }
32957 {
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 result = (bool)(arg1)->Navigate(arg2);
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 {
32964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32965 }
32966 return resultobj;
32967 fail:
32968 return NULL;
32969 }
32970
32971
32972 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32973 PyObject *resultobj = 0;
32974 wxWindow *arg1 = (wxWindow *) 0 ;
32975 wxWindow *arg2 = (wxWindow *) 0 ;
32976 void *argp1 = 0 ;
32977 int res1 = 0 ;
32978 void *argp2 = 0 ;
32979 int res2 = 0 ;
32980 PyObject * obj0 = 0 ;
32981 PyObject * obj1 = 0 ;
32982 char * kwnames[] = {
32983 (char *) "self",(char *) "win", NULL
32984 };
32985
32986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32988 if (!SWIG_IsOK(res1)) {
32989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32990 }
32991 arg1 = reinterpret_cast< wxWindow * >(argp1);
32992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32993 if (!SWIG_IsOK(res2)) {
32994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32995 }
32996 arg2 = reinterpret_cast< wxWindow * >(argp2);
32997 {
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 (arg1)->MoveAfterInTabOrder(arg2);
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 resultobj = SWIG_Py_Void();
33004 return resultobj;
33005 fail:
33006 return NULL;
33007 }
33008
33009
33010 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33011 PyObject *resultobj = 0;
33012 wxWindow *arg1 = (wxWindow *) 0 ;
33013 wxWindow *arg2 = (wxWindow *) 0 ;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 void *argp2 = 0 ;
33017 int res2 = 0 ;
33018 PyObject * obj0 = 0 ;
33019 PyObject * obj1 = 0 ;
33020 char * kwnames[] = {
33021 (char *) "self",(char *) "win", NULL
33022 };
33023
33024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33026 if (!SWIG_IsOK(res1)) {
33027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33028 }
33029 arg1 = reinterpret_cast< wxWindow * >(argp1);
33030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33031 if (!SWIG_IsOK(res2)) {
33032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33033 }
33034 arg2 = reinterpret_cast< wxWindow * >(argp2);
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->MoveBeforeInTabOrder(arg2);
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 resultobj = SWIG_Py_Void();
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 PyObject *result = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 PyObject *swig_obj[1] ;
33055
33056 if (!args) SWIG_fail;
33057 swig_obj[0] = args;
33058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (PyObject *)wxWindow_GetChildren(arg1);
33066 wxPyEndAllowThreads(__tstate);
33067 if (PyErr_Occurred()) SWIG_fail;
33068 }
33069 resultobj = result;
33070 return resultobj;
33071 fail:
33072 return NULL;
33073 }
33074
33075
33076 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33077 PyObject *resultobj = 0;
33078 wxWindow *arg1 = (wxWindow *) 0 ;
33079 wxWindow *result = 0 ;
33080 void *argp1 = 0 ;
33081 int res1 = 0 ;
33082 PyObject *swig_obj[1] ;
33083
33084 if (!args) SWIG_fail;
33085 swig_obj[0] = args;
33086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33087 if (!SWIG_IsOK(res1)) {
33088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33089 }
33090 arg1 = reinterpret_cast< wxWindow * >(argp1);
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 {
33098 resultobj = wxPyMake_wxObject(result, 0);
33099 }
33100 return resultobj;
33101 fail:
33102 return NULL;
33103 }
33104
33105
33106 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33107 PyObject *resultobj = 0;
33108 wxWindow *arg1 = (wxWindow *) 0 ;
33109 wxWindow *result = 0 ;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 PyObject *swig_obj[1] ;
33113
33114 if (!args) SWIG_fail;
33115 swig_obj[0] = args;
33116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33117 if (!SWIG_IsOK(res1)) {
33118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33119 }
33120 arg1 = reinterpret_cast< wxWindow * >(argp1);
33121 {
33122 PyThreadState* __tstate = wxPyBeginAllowThreads();
33123 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 {
33128 resultobj = wxPyMake_wxObject(result, 0);
33129 }
33130 return resultobj;
33131 fail:
33132 return NULL;
33133 }
33134
33135
33136 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33137 PyObject *resultobj = 0;
33138 wxWindow *arg1 = (wxWindow *) 0 ;
33139 bool result;
33140 void *argp1 = 0 ;
33141 int res1 = 0 ;
33142 PyObject *swig_obj[1] ;
33143
33144 if (!args) SWIG_fail;
33145 swig_obj[0] = args;
33146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33147 if (!SWIG_IsOK(res1)) {
33148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33149 }
33150 arg1 = reinterpret_cast< wxWindow * >(argp1);
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33154 wxPyEndAllowThreads(__tstate);
33155 if (PyErr_Occurred()) SWIG_fail;
33156 }
33157 {
33158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33159 }
33160 return resultobj;
33161 fail:
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 wxWindow *arg2 = (wxWindow *) 0 ;
33170 bool result;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 void *argp2 = 0 ;
33174 int res2 = 0 ;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 char * kwnames[] = {
33178 (char *) "self",(char *) "newParent", NULL
33179 };
33180
33181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33183 if (!SWIG_IsOK(res1)) {
33184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33185 }
33186 arg1 = reinterpret_cast< wxWindow * >(argp1);
33187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33188 if (!SWIG_IsOK(res2)) {
33189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33190 }
33191 arg2 = reinterpret_cast< wxWindow * >(argp2);
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 result = (bool)(arg1)->Reparent(arg2);
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 {
33199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33200 }
33201 return resultobj;
33202 fail:
33203 return NULL;
33204 }
33205
33206
33207 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33208 PyObject *resultobj = 0;
33209 wxWindow *arg1 = (wxWindow *) 0 ;
33210 wxWindow *arg2 = (wxWindow *) 0 ;
33211 void *argp1 = 0 ;
33212 int res1 = 0 ;
33213 void *argp2 = 0 ;
33214 int res2 = 0 ;
33215 PyObject * obj0 = 0 ;
33216 PyObject * obj1 = 0 ;
33217 char * kwnames[] = {
33218 (char *) "self",(char *) "child", NULL
33219 };
33220
33221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33225 }
33226 arg1 = reinterpret_cast< wxWindow * >(argp1);
33227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res2)) {
33229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33230 }
33231 arg2 = reinterpret_cast< wxWindow * >(argp2);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 (arg1)->AddChild(arg2);
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_Py_Void();
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33246 PyObject *resultobj = 0;
33247 wxWindow *arg1 = (wxWindow *) 0 ;
33248 wxWindow *arg2 = (wxWindow *) 0 ;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 void *argp2 = 0 ;
33252 int res2 = 0 ;
33253 PyObject * obj0 = 0 ;
33254 PyObject * obj1 = 0 ;
33255 char * kwnames[] = {
33256 (char *) "self",(char *) "child", NULL
33257 };
33258
33259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33263 }
33264 arg1 = reinterpret_cast< wxWindow * >(argp1);
33265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33266 if (!SWIG_IsOK(res2)) {
33267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33268 }
33269 arg2 = reinterpret_cast< wxWindow * >(argp2);
33270 {
33271 PyThreadState* __tstate = wxPyBeginAllowThreads();
33272 (arg1)->RemoveChild(arg2);
33273 wxPyEndAllowThreads(__tstate);
33274 if (PyErr_Occurred()) SWIG_fail;
33275 }
33276 resultobj = SWIG_Py_Void();
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33284 PyObject *resultobj = 0;
33285 wxWindow *arg1 = (wxWindow *) 0 ;
33286 bool arg2 ;
33287 void *argp1 = 0 ;
33288 int res1 = 0 ;
33289 bool val2 ;
33290 int ecode2 = 0 ;
33291 PyObject * obj0 = 0 ;
33292 PyObject * obj1 = 0 ;
33293 char * kwnames[] = {
33294 (char *) "self",(char *) "on", NULL
33295 };
33296
33297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33301 }
33302 arg1 = reinterpret_cast< wxWindow * >(argp1);
33303 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33304 if (!SWIG_IsOK(ecode2)) {
33305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33306 }
33307 arg2 = static_cast< bool >(val2);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 wxWindow_SetDoubleBuffered(arg1,arg2);
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_Py_Void();
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33322 PyObject *resultobj = 0;
33323 wxWindow *arg1 = (wxWindow *) 0 ;
33324 long arg2 ;
33325 wxWindow *result = 0 ;
33326 void *argp1 = 0 ;
33327 int res1 = 0 ;
33328 long val2 ;
33329 int ecode2 = 0 ;
33330 PyObject * obj0 = 0 ;
33331 PyObject * obj1 = 0 ;
33332 char * kwnames[] = {
33333 (char *) "self",(char *) "winid", NULL
33334 };
33335
33336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33338 if (!SWIG_IsOK(res1)) {
33339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33340 }
33341 arg1 = reinterpret_cast< wxWindow * >(argp1);
33342 ecode2 = SWIG_AsVal_long(obj1, &val2);
33343 if (!SWIG_IsOK(ecode2)) {
33344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33345 }
33346 arg2 = static_cast< long >(val2);
33347 {
33348 PyThreadState* __tstate = wxPyBeginAllowThreads();
33349 result = (wxWindow *)(arg1)->FindWindow(arg2);
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 {
33354 resultobj = wxPyMake_wxObject(result, 0);
33355 }
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj = 0;
33364 wxWindow *arg1 = (wxWindow *) 0 ;
33365 wxString *arg2 = 0 ;
33366 wxWindow *result = 0 ;
33367 void *argp1 = 0 ;
33368 int res1 = 0 ;
33369 bool temp2 = false ;
33370 PyObject * obj0 = 0 ;
33371 PyObject * obj1 = 0 ;
33372 char * kwnames[] = {
33373 (char *) "self",(char *) "name", NULL
33374 };
33375
33376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33378 if (!SWIG_IsOK(res1)) {
33379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33380 }
33381 arg1 = reinterpret_cast< wxWindow * >(argp1);
33382 {
33383 arg2 = wxString_in_helper(obj1);
33384 if (arg2 == NULL) SWIG_fail;
33385 temp2 = true;
33386 }
33387 {
33388 PyThreadState* __tstate = wxPyBeginAllowThreads();
33389 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 {
33394 resultobj = wxPyMake_wxObject(result, 0);
33395 }
33396 {
33397 if (temp2)
33398 delete arg2;
33399 }
33400 return resultobj;
33401 fail:
33402 {
33403 if (temp2)
33404 delete arg2;
33405 }
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxWindow *arg1 = (wxWindow *) 0 ;
33413 wxEvtHandler *result = 0 ;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33423 }
33424 arg1 = reinterpret_cast< wxWindow * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 resultobj = wxPyMake_wxObject(result, 0);
33433 }
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33441 PyObject *resultobj = 0;
33442 wxWindow *arg1 = (wxWindow *) 0 ;
33443 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 void *argp2 = 0 ;
33447 int res2 = 0 ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 char * kwnames[] = {
33451 (char *) "self",(char *) "handler", NULL
33452 };
33453
33454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33456 if (!SWIG_IsOK(res1)) {
33457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33458 }
33459 arg1 = reinterpret_cast< wxWindow * >(argp1);
33460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33461 if (!SWIG_IsOK(res2)) {
33462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33463 }
33464 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33465 {
33466 PyThreadState* __tstate = wxPyBeginAllowThreads();
33467 (arg1)->SetEventHandler(arg2);
33468 wxPyEndAllowThreads(__tstate);
33469 if (PyErr_Occurred()) SWIG_fail;
33470 }
33471 resultobj = SWIG_Py_Void();
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33479 PyObject *resultobj = 0;
33480 wxWindow *arg1 = (wxWindow *) 0 ;
33481 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 void *argp2 = 0 ;
33485 int res2 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "handler", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33496 }
33497 arg1 = reinterpret_cast< wxWindow * >(argp1);
33498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33499 if (!SWIG_IsOK(res2)) {
33500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33501 }
33502 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33503 {
33504 PyThreadState* __tstate = wxPyBeginAllowThreads();
33505 (arg1)->PushEventHandler(arg2);
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 resultobj = SWIG_Py_Void();
33510 return resultobj;
33511 fail:
33512 return NULL;
33513 }
33514
33515
33516 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33517 PyObject *resultobj = 0;
33518 wxWindow *arg1 = (wxWindow *) 0 ;
33519 bool arg2 = (bool) false ;
33520 wxEvtHandler *result = 0 ;
33521 void *argp1 = 0 ;
33522 int res1 = 0 ;
33523 bool val2 ;
33524 int ecode2 = 0 ;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 char * kwnames[] = {
33528 (char *) "self",(char *) "deleteHandler", NULL
33529 };
33530
33531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33533 if (!SWIG_IsOK(res1)) {
33534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33535 }
33536 arg1 = reinterpret_cast< wxWindow * >(argp1);
33537 if (obj1) {
33538 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33539 if (!SWIG_IsOK(ecode2)) {
33540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33541 }
33542 arg2 = static_cast< bool >(val2);
33543 }
33544 {
33545 PyThreadState* __tstate = wxPyBeginAllowThreads();
33546 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 {
33551 resultobj = wxPyMake_wxObject(result, 0);
33552 }
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33563 bool result;
33564 void *argp1 = 0 ;
33565 int res1 = 0 ;
33566 void *argp2 = 0 ;
33567 int res2 = 0 ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 char * kwnames[] = {
33571 (char *) "self",(char *) "handler", NULL
33572 };
33573
33574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33576 if (!SWIG_IsOK(res1)) {
33577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33578 }
33579 arg1 = reinterpret_cast< wxWindow * >(argp1);
33580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33581 if (!SWIG_IsOK(res2)) {
33582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33583 }
33584 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 result = (bool)(arg1)->RemoveEventHandler(arg2);
33588 wxPyEndAllowThreads(__tstate);
33589 if (PyErr_Occurred()) SWIG_fail;
33590 }
33591 {
33592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33593 }
33594 return resultobj;
33595 fail:
33596 return NULL;
33597 }
33598
33599
33600 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33601 PyObject *resultobj = 0;
33602 wxWindow *arg1 = (wxWindow *) 0 ;
33603 wxValidator *arg2 = 0 ;
33604 void *argp1 = 0 ;
33605 int res1 = 0 ;
33606 void *argp2 = 0 ;
33607 int res2 = 0 ;
33608 PyObject * obj0 = 0 ;
33609 PyObject * obj1 = 0 ;
33610 char * kwnames[] = {
33611 (char *) "self",(char *) "validator", NULL
33612 };
33613
33614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33616 if (!SWIG_IsOK(res1)) {
33617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33618 }
33619 arg1 = reinterpret_cast< wxWindow * >(argp1);
33620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33621 if (!SWIG_IsOK(res2)) {
33622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33623 }
33624 if (!argp2) {
33625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33626 }
33627 arg2 = reinterpret_cast< wxValidator * >(argp2);
33628 {
33629 PyThreadState* __tstate = wxPyBeginAllowThreads();
33630 (arg1)->SetValidator((wxValidator const &)*arg2);
33631 wxPyEndAllowThreads(__tstate);
33632 if (PyErr_Occurred()) SWIG_fail;
33633 }
33634 resultobj = SWIG_Py_Void();
33635 return resultobj;
33636 fail:
33637 return NULL;
33638 }
33639
33640
33641 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33642 PyObject *resultobj = 0;
33643 wxWindow *arg1 = (wxWindow *) 0 ;
33644 wxValidator *result = 0 ;
33645 void *argp1 = 0 ;
33646 int res1 = 0 ;
33647 PyObject *swig_obj[1] ;
33648
33649 if (!args) SWIG_fail;
33650 swig_obj[0] = args;
33651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33652 if (!SWIG_IsOK(res1)) {
33653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33654 }
33655 arg1 = reinterpret_cast< wxWindow * >(argp1);
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 result = (wxValidator *)(arg1)->GetValidator();
33659 wxPyEndAllowThreads(__tstate);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 }
33662 {
33663 resultobj = wxPyMake_wxObject(result, (bool)0);
33664 }
33665 return resultobj;
33666 fail:
33667 return NULL;
33668 }
33669
33670
33671 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33672 PyObject *resultobj = 0;
33673 wxWindow *arg1 = (wxWindow *) 0 ;
33674 bool result;
33675 void *argp1 = 0 ;
33676 int res1 = 0 ;
33677 PyObject *swig_obj[1] ;
33678
33679 if (!args) SWIG_fail;
33680 swig_obj[0] = args;
33681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33682 if (!SWIG_IsOK(res1)) {
33683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33684 }
33685 arg1 = reinterpret_cast< wxWindow * >(argp1);
33686 {
33687 PyThreadState* __tstate = wxPyBeginAllowThreads();
33688 result = (bool)(arg1)->Validate();
33689 wxPyEndAllowThreads(__tstate);
33690 if (PyErr_Occurred()) SWIG_fail;
33691 }
33692 {
33693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33694 }
33695 return resultobj;
33696 fail:
33697 return NULL;
33698 }
33699
33700
33701 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33702 PyObject *resultobj = 0;
33703 wxWindow *arg1 = (wxWindow *) 0 ;
33704 bool result;
33705 void *argp1 = 0 ;
33706 int res1 = 0 ;
33707 PyObject *swig_obj[1] ;
33708
33709 if (!args) SWIG_fail;
33710 swig_obj[0] = args;
33711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33712 if (!SWIG_IsOK(res1)) {
33713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33714 }
33715 arg1 = reinterpret_cast< wxWindow * >(argp1);
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 result = (bool)(arg1)->TransferDataToWindow();
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 {
33723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33724 }
33725 return resultobj;
33726 fail:
33727 return NULL;
33728 }
33729
33730
33731 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33732 PyObject *resultobj = 0;
33733 wxWindow *arg1 = (wxWindow *) 0 ;
33734 bool result;
33735 void *argp1 = 0 ;
33736 int res1 = 0 ;
33737 PyObject *swig_obj[1] ;
33738
33739 if (!args) SWIG_fail;
33740 swig_obj[0] = args;
33741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33742 if (!SWIG_IsOK(res1)) {
33743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33744 }
33745 arg1 = reinterpret_cast< wxWindow * >(argp1);
33746 {
33747 PyThreadState* __tstate = wxPyBeginAllowThreads();
33748 result = (bool)(arg1)->TransferDataFromWindow();
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 {
33753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33754 }
33755 return resultobj;
33756 fail:
33757 return NULL;
33758 }
33759
33760
33761 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33762 PyObject *resultobj = 0;
33763 wxWindow *arg1 = (wxWindow *) 0 ;
33764 void *argp1 = 0 ;
33765 int res1 = 0 ;
33766 PyObject *swig_obj[1] ;
33767
33768 if (!args) SWIG_fail;
33769 swig_obj[0] = args;
33770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 {
33776 PyThreadState* __tstate = wxPyBeginAllowThreads();
33777 (arg1)->InitDialog();
33778 wxPyEndAllowThreads(__tstate);
33779 if (PyErr_Occurred()) SWIG_fail;
33780 }
33781 resultobj = SWIG_Py_Void();
33782 return resultobj;
33783 fail:
33784 return NULL;
33785 }
33786
33787
33788 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33789 PyObject *resultobj = 0;
33790 wxWindow *arg1 = (wxWindow *) 0 ;
33791 wxAcceleratorTable *arg2 = 0 ;
33792 void *argp1 = 0 ;
33793 int res1 = 0 ;
33794 void *argp2 = 0 ;
33795 int res2 = 0 ;
33796 PyObject * obj0 = 0 ;
33797 PyObject * obj1 = 0 ;
33798 char * kwnames[] = {
33799 (char *) "self",(char *) "accel", NULL
33800 };
33801
33802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33806 }
33807 arg1 = reinterpret_cast< wxWindow * >(argp1);
33808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33809 if (!SWIG_IsOK(res2)) {
33810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33811 }
33812 if (!argp2) {
33813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33814 }
33815 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33819 wxPyEndAllowThreads(__tstate);
33820 if (PyErr_Occurred()) SWIG_fail;
33821 }
33822 resultobj = SWIG_Py_Void();
33823 return resultobj;
33824 fail:
33825 return NULL;
33826 }
33827
33828
33829 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33830 PyObject *resultobj = 0;
33831 wxWindow *arg1 = (wxWindow *) 0 ;
33832 wxAcceleratorTable *result = 0 ;
33833 void *argp1 = 0 ;
33834 int res1 = 0 ;
33835 PyObject *swig_obj[1] ;
33836
33837 if (!args) SWIG_fail;
33838 swig_obj[0] = args;
33839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33842 }
33843 arg1 = reinterpret_cast< wxWindow * >(argp1);
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 int arg2 ;
33861 int arg3 ;
33862 int arg4 ;
33863 bool result;
33864 void *argp1 = 0 ;
33865 int res1 = 0 ;
33866 int val2 ;
33867 int ecode2 = 0 ;
33868 int val3 ;
33869 int ecode3 = 0 ;
33870 int val4 ;
33871 int ecode4 = 0 ;
33872 PyObject * obj0 = 0 ;
33873 PyObject * obj1 = 0 ;
33874 PyObject * obj2 = 0 ;
33875 PyObject * obj3 = 0 ;
33876 char * kwnames[] = {
33877 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33878 };
33879
33880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33884 }
33885 arg1 = reinterpret_cast< wxWindow * >(argp1);
33886 ecode2 = SWIG_AsVal_int(obj1, &val2);
33887 if (!SWIG_IsOK(ecode2)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33889 }
33890 arg2 = static_cast< int >(val2);
33891 ecode3 = SWIG_AsVal_int(obj2, &val3);
33892 if (!SWIG_IsOK(ecode3)) {
33893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33894 }
33895 arg3 = static_cast< int >(val3);
33896 ecode4 = SWIG_AsVal_int(obj3, &val4);
33897 if (!SWIG_IsOK(ecode4)) {
33898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33899 }
33900 arg4 = static_cast< int >(val4);
33901 {
33902 PyThreadState* __tstate = wxPyBeginAllowThreads();
33903 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj = 0;
33918 wxWindow *arg1 = (wxWindow *) 0 ;
33919 int arg2 ;
33920 bool result;
33921 void *argp1 = 0 ;
33922 int res1 = 0 ;
33923 int val2 ;
33924 int ecode2 = 0 ;
33925 PyObject * obj0 = 0 ;
33926 PyObject * obj1 = 0 ;
33927 char * kwnames[] = {
33928 (char *) "self",(char *) "hotkeyId", NULL
33929 };
33930
33931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33933 if (!SWIG_IsOK(res1)) {
33934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33935 }
33936 arg1 = reinterpret_cast< wxWindow * >(argp1);
33937 ecode2 = SWIG_AsVal_int(obj1, &val2);
33938 if (!SWIG_IsOK(ecode2)) {
33939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33940 }
33941 arg2 = static_cast< int >(val2);
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 {
33949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33950 }
33951 return resultobj;
33952 fail:
33953 return NULL;
33954 }
33955
33956
33957 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33958 PyObject *resultobj = 0;
33959 wxWindow *arg1 = (wxWindow *) 0 ;
33960 wxPoint *arg2 = 0 ;
33961 wxPoint result;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 wxPoint temp2 ;
33965 PyObject * obj0 = 0 ;
33966 PyObject * obj1 = 0 ;
33967 char * kwnames[] = {
33968 (char *) "self",(char *) "pt", NULL
33969 };
33970
33971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33973 if (!SWIG_IsOK(res1)) {
33974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33975 }
33976 arg1 = reinterpret_cast< wxWindow * >(argp1);
33977 {
33978 arg2 = &temp2;
33979 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33980 }
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 wxSize *arg2 = 0 ;
33998 wxSize result;
33999 void *argp1 = 0 ;
34000 int res1 = 0 ;
34001 wxSize temp2 ;
34002 PyObject * obj0 = 0 ;
34003 PyObject * obj1 = 0 ;
34004 char * kwnames[] = {
34005 (char *) "self",(char *) "sz", NULL
34006 };
34007
34008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34010 if (!SWIG_IsOK(res1)) {
34011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34012 }
34013 arg1 = reinterpret_cast< wxWindow * >(argp1);
34014 {
34015 arg2 = &temp2;
34016 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34017 }
34018 {
34019 PyThreadState* __tstate = wxPyBeginAllowThreads();
34020 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34025 return resultobj;
34026 fail:
34027 return NULL;
34028 }
34029
34030
34031 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34032 PyObject *resultobj = 0;
34033 wxWindow *arg1 = (wxWindow *) 0 ;
34034 wxPoint *arg2 = 0 ;
34035 wxPoint result;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 wxPoint temp2 ;
34039 PyObject * obj0 = 0 ;
34040 PyObject * obj1 = 0 ;
34041 char * kwnames[] = {
34042 (char *) "self",(char *) "pt", NULL
34043 };
34044
34045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34047 if (!SWIG_IsOK(res1)) {
34048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34049 }
34050 arg1 = reinterpret_cast< wxWindow * >(argp1);
34051 {
34052 arg2 = &temp2;
34053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34054 }
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj = 0;
34070 wxWindow *arg1 = (wxWindow *) 0 ;
34071 wxSize *arg2 = 0 ;
34072 wxSize result;
34073 void *argp1 = 0 ;
34074 int res1 = 0 ;
34075 wxSize temp2 ;
34076 PyObject * obj0 = 0 ;
34077 PyObject * obj1 = 0 ;
34078 char * kwnames[] = {
34079 (char *) "self",(char *) "sz", NULL
34080 };
34081
34082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34084 if (!SWIG_IsOK(res1)) {
34085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34086 }
34087 arg1 = reinterpret_cast< wxWindow * >(argp1);
34088 {
34089 arg2 = &temp2;
34090 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34091 }
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34099 return resultobj;
34100 fail:
34101 return NULL;
34102 }
34103
34104
34105 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34106 PyObject *resultobj = 0;
34107 wxWindow *arg1 = (wxWindow *) 0 ;
34108 wxPoint *arg2 = 0 ;
34109 wxPoint result;
34110 void *argp1 = 0 ;
34111 int res1 = 0 ;
34112 wxPoint temp2 ;
34113 PyObject * obj0 = 0 ;
34114 PyObject * obj1 = 0 ;
34115 char * kwnames[] = {
34116 (char *) "self",(char *) "pt", NULL
34117 };
34118
34119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34123 }
34124 arg1 = reinterpret_cast< wxWindow * >(argp1);
34125 {
34126 arg2 = &temp2;
34127 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34128 }
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34136 return resultobj;
34137 fail:
34138 return NULL;
34139 }
34140
34141
34142 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj = 0;
34144 wxWindow *arg1 = (wxWindow *) 0 ;
34145 wxSize *arg2 = 0 ;
34146 wxSize result;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 wxSize temp2 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 char * kwnames[] = {
34153 (char *) "self",(char *) "sz", NULL
34154 };
34155
34156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34158 if (!SWIG_IsOK(res1)) {
34159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34160 }
34161 arg1 = reinterpret_cast< wxWindow * >(argp1);
34162 {
34163 arg2 = &temp2;
34164 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34165 }
34166 {
34167 PyThreadState* __tstate = wxPyBeginAllowThreads();
34168 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34169 wxPyEndAllowThreads(__tstate);
34170 if (PyErr_Occurred()) SWIG_fail;
34171 }
34172 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34173 return resultobj;
34174 fail:
34175 return NULL;
34176 }
34177
34178
34179 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34180 PyObject *resultobj = 0;
34181 wxWindow *arg1 = (wxWindow *) 0 ;
34182 int arg2 ;
34183 int arg3 ;
34184 void *argp1 = 0 ;
34185 int res1 = 0 ;
34186 int val2 ;
34187 int ecode2 = 0 ;
34188 int val3 ;
34189 int ecode3 = 0 ;
34190 PyObject * obj0 = 0 ;
34191 PyObject * obj1 = 0 ;
34192 PyObject * obj2 = 0 ;
34193 char * kwnames[] = {
34194 (char *) "self",(char *) "x",(char *) "y", NULL
34195 };
34196
34197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34201 }
34202 arg1 = reinterpret_cast< wxWindow * >(argp1);
34203 ecode2 = SWIG_AsVal_int(obj1, &val2);
34204 if (!SWIG_IsOK(ecode2)) {
34205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34206 }
34207 arg2 = static_cast< int >(val2);
34208 ecode3 = SWIG_AsVal_int(obj2, &val3);
34209 if (!SWIG_IsOK(ecode3)) {
34210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34211 }
34212 arg3 = static_cast< int >(val3);
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 (arg1)->WarpPointer(arg2,arg3);
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 resultobj = SWIG_Py_Void();
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34227 PyObject *resultobj = 0;
34228 wxWindow *arg1 = (wxWindow *) 0 ;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 (arg1)->CaptureMouse();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_Py_Void();
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 PyObject *resultobj = 0;
34255 wxWindow *arg1 = (wxWindow *) 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 PyObject *swig_obj[1] ;
34259
34260 if (!args) SWIG_fail;
34261 swig_obj[0] = args;
34262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34263 if (!SWIG_IsOK(res1)) {
34264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34265 }
34266 arg1 = reinterpret_cast< wxWindow * >(argp1);
34267 {
34268 PyThreadState* __tstate = wxPyBeginAllowThreads();
34269 (arg1)->ReleaseMouse();
34270 wxPyEndAllowThreads(__tstate);
34271 if (PyErr_Occurred()) SWIG_fail;
34272 }
34273 resultobj = SWIG_Py_Void();
34274 return resultobj;
34275 fail:
34276 return NULL;
34277 }
34278
34279
34280 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34281 PyObject *resultobj = 0;
34282 wxWindow *result = 0 ;
34283
34284 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34285 {
34286 if (!wxPyCheckForApp()) SWIG_fail;
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 result = (wxWindow *)wxWindow::GetCapture();
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 {
34293 resultobj = wxPyMake_wxObject(result, 0);
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 bool result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 result = (bool)((wxWindow const *)arg1)->HasCapture();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 {
34323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34324 }
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj = 0;
34333 wxWindow *arg1 = (wxWindow *) 0 ;
34334 bool arg2 = (bool) true ;
34335 wxRect *arg3 = (wxRect *) NULL ;
34336 void *argp1 = 0 ;
34337 int res1 = 0 ;
34338 bool val2 ;
34339 int ecode2 = 0 ;
34340 void *argp3 = 0 ;
34341 int res3 = 0 ;
34342 PyObject * obj0 = 0 ;
34343 PyObject * obj1 = 0 ;
34344 PyObject * obj2 = 0 ;
34345 char * kwnames[] = {
34346 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34347 };
34348
34349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34353 }
34354 arg1 = reinterpret_cast< wxWindow * >(argp1);
34355 if (obj1) {
34356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34357 if (!SWIG_IsOK(ecode2)) {
34358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34359 }
34360 arg2 = static_cast< bool >(val2);
34361 }
34362 if (obj2) {
34363 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34364 if (!SWIG_IsOK(res3)) {
34365 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34366 }
34367 arg3 = reinterpret_cast< wxRect * >(argp3);
34368 }
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 resultobj = SWIG_Py_Void();
34376 return resultobj;
34377 fail:
34378 return NULL;
34379 }
34380
34381
34382 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34383 PyObject *resultobj = 0;
34384 wxWindow *arg1 = (wxWindow *) 0 ;
34385 wxRect *arg2 = 0 ;
34386 bool arg3 = (bool) true ;
34387 void *argp1 = 0 ;
34388 int res1 = 0 ;
34389 wxRect temp2 ;
34390 bool val3 ;
34391 int ecode3 = 0 ;
34392 PyObject * obj0 = 0 ;
34393 PyObject * obj1 = 0 ;
34394 PyObject * obj2 = 0 ;
34395 char * kwnames[] = {
34396 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34397 };
34398
34399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34401 if (!SWIG_IsOK(res1)) {
34402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34403 }
34404 arg1 = reinterpret_cast< wxWindow * >(argp1);
34405 {
34406 arg2 = &temp2;
34407 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34408 }
34409 if (obj2) {
34410 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34411 if (!SWIG_IsOK(ecode3)) {
34412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34413 }
34414 arg3 = static_cast< bool >(val3);
34415 }
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 resultobj = SWIG_Py_Void();
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 void *argp1 = 0 ;
34433 int res1 = 0 ;
34434 PyObject *swig_obj[1] ;
34435
34436 if (!args) SWIG_fail;
34437 swig_obj[0] = args;
34438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34439 if (!SWIG_IsOK(res1)) {
34440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34441 }
34442 arg1 = reinterpret_cast< wxWindow * >(argp1);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->Update();
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 void *argp1 = 0 ;
34460 int res1 = 0 ;
34461 PyObject *swig_obj[1] ;
34462
34463 if (!args) SWIG_fail;
34464 swig_obj[0] = args;
34465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34466 if (!SWIG_IsOK(res1)) {
34467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34468 }
34469 arg1 = reinterpret_cast< wxWindow * >(argp1);
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 (arg1)->ClearBackground();
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_Py_Void();
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 void *argp1 = 0 ;
34487 int res1 = 0 ;
34488 PyObject *swig_obj[1] ;
34489
34490 if (!args) SWIG_fail;
34491 swig_obj[0] = args;
34492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34495 }
34496 arg1 = reinterpret_cast< wxWindow * >(argp1);
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 (arg1)->Freeze();
34500 wxPyEndAllowThreads(__tstate);
34501 if (PyErr_Occurred()) SWIG_fail;
34502 }
34503 resultobj = SWIG_Py_Void();
34504 return resultobj;
34505 fail:
34506 return NULL;
34507 }
34508
34509
34510 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34511 PyObject *resultobj = 0;
34512 wxWindow *arg1 = (wxWindow *) 0 ;
34513 void *argp1 = 0 ;
34514 int res1 = 0 ;
34515 PyObject *swig_obj[1] ;
34516
34517 if (!args) SWIG_fail;
34518 swig_obj[0] = args;
34519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34520 if (!SWIG_IsOK(res1)) {
34521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34522 }
34523 arg1 = reinterpret_cast< wxWindow * >(argp1);
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 (arg1)->Thaw();
34527 wxPyEndAllowThreads(__tstate);
34528 if (PyErr_Occurred()) SWIG_fail;
34529 }
34530 resultobj = SWIG_Py_Void();
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34538 PyObject *resultobj = 0;
34539 wxWindow *arg1 = (wxWindow *) 0 ;
34540 wxDC *arg2 = 0 ;
34541 void *argp1 = 0 ;
34542 int res1 = 0 ;
34543 void *argp2 = 0 ;
34544 int res2 = 0 ;
34545 PyObject * obj0 = 0 ;
34546 PyObject * obj1 = 0 ;
34547 char * kwnames[] = {
34548 (char *) "self",(char *) "dc", NULL
34549 };
34550
34551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34555 }
34556 arg1 = reinterpret_cast< wxWindow * >(argp1);
34557 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34558 if (!SWIG_IsOK(res2)) {
34559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34560 }
34561 if (!argp2) {
34562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34563 }
34564 arg2 = reinterpret_cast< wxDC * >(argp2);
34565 {
34566 PyThreadState* __tstate = wxPyBeginAllowThreads();
34567 (arg1)->PrepareDC(*arg2);
34568 wxPyEndAllowThreads(__tstate);
34569 if (PyErr_Occurred()) SWIG_fail;
34570 }
34571 resultobj = SWIG_Py_Void();
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34579 PyObject *resultobj = 0;
34580 wxWindow *arg1 = (wxWindow *) 0 ;
34581 wxRegion *result = 0 ;
34582 void *argp1 = 0 ;
34583 int res1 = 0 ;
34584 PyObject *swig_obj[1] ;
34585
34586 if (!args) SWIG_fail;
34587 swig_obj[0] = args;
34588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34589 if (!SWIG_IsOK(res1)) {
34590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34591 }
34592 arg1 = reinterpret_cast< wxWindow * >(argp1);
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 {
34596 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34597 result = (wxRegion *) &_result_ref;
34598 }
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 wxRect result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 int arg2 ;
34641 int arg3 ;
34642 int arg4 = (int) 1 ;
34643 int arg5 = (int) 1 ;
34644 bool result;
34645 void *argp1 = 0 ;
34646 int res1 = 0 ;
34647 int val2 ;
34648 int ecode2 = 0 ;
34649 int val3 ;
34650 int ecode3 = 0 ;
34651 int val4 ;
34652 int ecode4 = 0 ;
34653 int val5 ;
34654 int ecode5 = 0 ;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 PyObject * obj2 = 0 ;
34658 PyObject * obj3 = 0 ;
34659 PyObject * obj4 = 0 ;
34660 char * kwnames[] = {
34661 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34662 };
34663
34664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34668 }
34669 arg1 = reinterpret_cast< wxWindow * >(argp1);
34670 ecode2 = SWIG_AsVal_int(obj1, &val2);
34671 if (!SWIG_IsOK(ecode2)) {
34672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34673 }
34674 arg2 = static_cast< int >(val2);
34675 ecode3 = SWIG_AsVal_int(obj2, &val3);
34676 if (!SWIG_IsOK(ecode3)) {
34677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34678 }
34679 arg3 = static_cast< int >(val3);
34680 if (obj3) {
34681 ecode4 = SWIG_AsVal_int(obj3, &val4);
34682 if (!SWIG_IsOK(ecode4)) {
34683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34684 }
34685 arg4 = static_cast< int >(val4);
34686 }
34687 if (obj4) {
34688 ecode5 = SWIG_AsVal_int(obj4, &val5);
34689 if (!SWIG_IsOK(ecode5)) {
34690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34691 }
34692 arg5 = static_cast< int >(val5);
34693 }
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34697 wxPyEndAllowThreads(__tstate);
34698 if (PyErr_Occurred()) SWIG_fail;
34699 }
34700 {
34701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34702 }
34703 return resultobj;
34704 fail:
34705 return NULL;
34706 }
34707
34708
34709 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34710 PyObject *resultobj = 0;
34711 wxWindow *arg1 = (wxWindow *) 0 ;
34712 wxPoint *arg2 = 0 ;
34713 bool result;
34714 void *argp1 = 0 ;
34715 int res1 = 0 ;
34716 wxPoint temp2 ;
34717 PyObject * obj0 = 0 ;
34718 PyObject * obj1 = 0 ;
34719 char * kwnames[] = {
34720 (char *) "self",(char *) "pt", NULL
34721 };
34722
34723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34725 if (!SWIG_IsOK(res1)) {
34726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34727 }
34728 arg1 = reinterpret_cast< wxWindow * >(argp1);
34729 {
34730 arg2 = &temp2;
34731 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34732 }
34733 {
34734 PyThreadState* __tstate = wxPyBeginAllowThreads();
34735 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 {
34740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34741 }
34742 return resultobj;
34743 fail:
34744 return NULL;
34745 }
34746
34747
34748 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj = 0;
34750 wxWindow *arg1 = (wxWindow *) 0 ;
34751 wxRect *arg2 = 0 ;
34752 bool result;
34753 void *argp1 = 0 ;
34754 int res1 = 0 ;
34755 wxRect temp2 ;
34756 PyObject * obj0 = 0 ;
34757 PyObject * obj1 = 0 ;
34758 char * kwnames[] = {
34759 (char *) "self",(char *) "rect", NULL
34760 };
34761
34762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34764 if (!SWIG_IsOK(res1)) {
34765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34766 }
34767 arg1 = reinterpret_cast< wxWindow * >(argp1);
34768 {
34769 arg2 = &temp2;
34770 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34771 }
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 {
34779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34780 }
34781 return resultobj;
34782 fail:
34783 return NULL;
34784 }
34785
34786
34787 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34788 PyObject *resultobj = 0;
34789 wxWindow *arg1 = (wxWindow *) 0 ;
34790 SwigValueWrapper<wxVisualAttributes > result;
34791 void *argp1 = 0 ;
34792 int res1 = 0 ;
34793 PyObject *swig_obj[1] ;
34794
34795 if (!args) SWIG_fail;
34796 swig_obj[0] = args;
34797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34798 if (!SWIG_IsOK(res1)) {
34799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34800 }
34801 arg1 = reinterpret_cast< wxWindow * >(argp1);
34802 {
34803 PyThreadState* __tstate = wxPyBeginAllowThreads();
34804 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34805 wxPyEndAllowThreads(__tstate);
34806 if (PyErr_Occurred()) SWIG_fail;
34807 }
34808 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34809 return resultobj;
34810 fail:
34811 return NULL;
34812 }
34813
34814
34815 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34816 PyObject *resultobj = 0;
34817 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34818 SwigValueWrapper<wxVisualAttributes > result;
34819 int val1 ;
34820 int ecode1 = 0 ;
34821 PyObject * obj0 = 0 ;
34822 char * kwnames[] = {
34823 (char *) "variant", NULL
34824 };
34825
34826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34827 if (obj0) {
34828 ecode1 = SWIG_AsVal_int(obj0, &val1);
34829 if (!SWIG_IsOK(ecode1)) {
34830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34831 }
34832 arg1 = static_cast< wxWindowVariant >(val1);
34833 }
34834 {
34835 if (!wxPyCheckForApp()) SWIG_fail;
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 result = wxWindow::GetClassDefaultAttributes(arg1);
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 wxColour *arg2 = 0 ;
34852 bool result;
34853 void *argp1 = 0 ;
34854 int res1 = 0 ;
34855 wxColour temp2 ;
34856 PyObject * obj0 = 0 ;
34857 PyObject * obj1 = 0 ;
34858 char * kwnames[] = {
34859 (char *) "self",(char *) "colour", NULL
34860 };
34861
34862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34864 if (!SWIG_IsOK(res1)) {
34865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34866 }
34867 arg1 = reinterpret_cast< wxWindow * >(argp1);
34868 {
34869 arg2 = &temp2;
34870 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34871 }
34872 {
34873 PyThreadState* __tstate = wxPyBeginAllowThreads();
34874 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34875 wxPyEndAllowThreads(__tstate);
34876 if (PyErr_Occurred()) SWIG_fail;
34877 }
34878 {
34879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34880 }
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj = 0;
34889 wxWindow *arg1 = (wxWindow *) 0 ;
34890 wxColour *arg2 = 0 ;
34891 void *argp1 = 0 ;
34892 int res1 = 0 ;
34893 wxColour temp2 ;
34894 PyObject * obj0 = 0 ;
34895 PyObject * obj1 = 0 ;
34896 char * kwnames[] = {
34897 (char *) "self",(char *) "colour", NULL
34898 };
34899
34900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34902 if (!SWIG_IsOK(res1)) {
34903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34904 }
34905 arg1 = reinterpret_cast< wxWindow * >(argp1);
34906 {
34907 arg2 = &temp2;
34908 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34909 }
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 resultobj = SWIG_Py_Void();
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj = 0;
34925 wxWindow *arg1 = (wxWindow *) 0 ;
34926 wxColour *arg2 = 0 ;
34927 bool result;
34928 void *argp1 = 0 ;
34929 int res1 = 0 ;
34930 wxColour temp2 ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char * kwnames[] = {
34934 (char *) "self",(char *) "colour", NULL
34935 };
34936
34937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 {
34944 arg2 = &temp2;
34945 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34946 }
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34963 PyObject *resultobj = 0;
34964 wxWindow *arg1 = (wxWindow *) 0 ;
34965 wxColour *arg2 = 0 ;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 wxColour temp2 ;
34969 PyObject * obj0 = 0 ;
34970 PyObject * obj1 = 0 ;
34971 char * kwnames[] = {
34972 (char *) "self",(char *) "colour", NULL
34973 };
34974
34975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34979 }
34980 arg1 = reinterpret_cast< wxWindow * >(argp1);
34981 {
34982 arg2 = &temp2;
34983 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34984 }
34985 {
34986 PyThreadState* __tstate = wxPyBeginAllowThreads();
34987 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34988 wxPyEndAllowThreads(__tstate);
34989 if (PyErr_Occurred()) SWIG_fail;
34990 }
34991 resultobj = SWIG_Py_Void();
34992 return resultobj;
34993 fail:
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34999 PyObject *resultobj = 0;
35000 wxWindow *arg1 = (wxWindow *) 0 ;
35001 wxColour result;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 PyObject *swig_obj[1] ;
35005
35006 if (!args) SWIG_fail;
35007 swig_obj[0] = args;
35008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35009 if (!SWIG_IsOK(res1)) {
35010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35011 }
35012 arg1 = reinterpret_cast< wxWindow * >(argp1);
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35016 wxPyEndAllowThreads(__tstate);
35017 if (PyErr_Occurred()) SWIG_fail;
35018 }
35019 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35020 return resultobj;
35021 fail:
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35027 PyObject *resultobj = 0;
35028 wxWindow *arg1 = (wxWindow *) 0 ;
35029 wxColour result;
35030 void *argp1 = 0 ;
35031 int res1 = 0 ;
35032 PyObject *swig_obj[1] ;
35033
35034 if (!args) SWIG_fail;
35035 swig_obj[0] = args;
35036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35037 if (!SWIG_IsOK(res1)) {
35038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35039 }
35040 arg1 = reinterpret_cast< wxWindow * >(argp1);
35041 {
35042 PyThreadState* __tstate = wxPyBeginAllowThreads();
35043 result = ((wxWindow const *)arg1)->GetForegroundColour();
35044 wxPyEndAllowThreads(__tstate);
35045 if (PyErr_Occurred()) SWIG_fail;
35046 }
35047 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35048 return resultobj;
35049 fail:
35050 return NULL;
35051 }
35052
35053
35054 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35055 PyObject *resultobj = 0;
35056 wxWindow *arg1 = (wxWindow *) 0 ;
35057 bool result;
35058 void *argp1 = 0 ;
35059 int res1 = 0 ;
35060 PyObject *swig_obj[1] ;
35061
35062 if (!args) SWIG_fail;
35063 swig_obj[0] = args;
35064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35065 if (!SWIG_IsOK(res1)) {
35066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35067 }
35068 arg1 = reinterpret_cast< wxWindow * >(argp1);
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35072 wxPyEndAllowThreads(__tstate);
35073 if (PyErr_Occurred()) SWIG_fail;
35074 }
35075 {
35076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35077 }
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 bool result;
35088 void *argp1 = 0 ;
35089 int res1 = 0 ;
35090 PyObject *swig_obj[1] ;
35091
35092 if (!args) SWIG_fail;
35093 swig_obj[0] = args;
35094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35095 if (!SWIG_IsOK(res1)) {
35096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35097 }
35098 arg1 = reinterpret_cast< wxWindow * >(argp1);
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 {
35106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35107 }
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxBackgroundStyle arg2 ;
35118 bool result;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 int val2 ;
35122 int ecode2 = 0 ;
35123 PyObject * obj0 = 0 ;
35124 PyObject * obj1 = 0 ;
35125 char * kwnames[] = {
35126 (char *) "self",(char *) "style", NULL
35127 };
35128
35129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35133 }
35134 arg1 = reinterpret_cast< wxWindow * >(argp1);
35135 ecode2 = SWIG_AsVal_int(obj1, &val2);
35136 if (!SWIG_IsOK(ecode2)) {
35137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35138 }
35139 arg2 = static_cast< wxBackgroundStyle >(val2);
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 {
35147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35148 }
35149 return resultobj;
35150 fail:
35151 return NULL;
35152 }
35153
35154
35155 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35156 PyObject *resultobj = 0;
35157 wxWindow *arg1 = (wxWindow *) 0 ;
35158 wxBackgroundStyle result;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 PyObject *swig_obj[1] ;
35162
35163 if (!args) SWIG_fail;
35164 swig_obj[0] = args;
35165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35166 if (!SWIG_IsOK(res1)) {
35167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35168 }
35169 arg1 = reinterpret_cast< wxWindow * >(argp1);
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 resultobj = SWIG_From_int(static_cast< int >(result));
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35184 PyObject *resultobj = 0;
35185 wxWindow *arg1 = (wxWindow *) 0 ;
35186 bool result;
35187 void *argp1 = 0 ;
35188 int res1 = 0 ;
35189 PyObject *swig_obj[1] ;
35190
35191 if (!args) SWIG_fail;
35192 swig_obj[0] = args;
35193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35194 if (!SWIG_IsOK(res1)) {
35195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35196 }
35197 arg1 = reinterpret_cast< wxWindow * >(argp1);
35198 {
35199 PyThreadState* __tstate = wxPyBeginAllowThreads();
35200 result = (bool)(arg1)->HasTransparentBackground();
35201 wxPyEndAllowThreads(__tstate);
35202 if (PyErr_Occurred()) SWIG_fail;
35203 }
35204 {
35205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35206 }
35207 return resultobj;
35208 fail:
35209 return NULL;
35210 }
35211
35212
35213 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj = 0;
35215 wxWindow *arg1 = (wxWindow *) 0 ;
35216 wxCursor *arg2 = 0 ;
35217 bool result;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 void *argp2 = 0 ;
35221 int res2 = 0 ;
35222 PyObject * obj0 = 0 ;
35223 PyObject * obj1 = 0 ;
35224 char * kwnames[] = {
35225 (char *) "self",(char *) "cursor", NULL
35226 };
35227
35228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35230 if (!SWIG_IsOK(res1)) {
35231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35232 }
35233 arg1 = reinterpret_cast< wxWindow * >(argp1);
35234 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35235 if (!SWIG_IsOK(res2)) {
35236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35237 }
35238 if (!argp2) {
35239 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35240 }
35241 arg2 = reinterpret_cast< wxCursor * >(argp2);
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 {
35249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35250 }
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 PyObject *resultobj = 0;
35259 wxWindow *arg1 = (wxWindow *) 0 ;
35260 wxCursor result;
35261 void *argp1 = 0 ;
35262 int res1 = 0 ;
35263 PyObject *swig_obj[1] ;
35264
35265 if (!args) SWIG_fail;
35266 swig_obj[0] = args;
35267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35268 if (!SWIG_IsOK(res1)) {
35269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35270 }
35271 arg1 = reinterpret_cast< wxWindow * >(argp1);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (arg1)->GetCursor();
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35286 PyObject *resultobj = 0;
35287 wxWindow *arg1 = (wxWindow *) 0 ;
35288 wxFont *arg2 = 0 ;
35289 bool result;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 void *argp2 = 0 ;
35293 int res2 = 0 ;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 char * kwnames[] = {
35297 (char *) "self",(char *) "font", NULL
35298 };
35299
35300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35307 if (!SWIG_IsOK(res2)) {
35308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35309 }
35310 if (!argp2) {
35311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35312 }
35313 arg2 = reinterpret_cast< wxFont * >(argp2);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 {
35321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35322 }
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35330 PyObject *resultobj = 0;
35331 wxWindow *arg1 = (wxWindow *) 0 ;
35332 wxFont *arg2 = 0 ;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 void *argp2 = 0 ;
35336 int res2 = 0 ;
35337 PyObject * obj0 = 0 ;
35338 PyObject * obj1 = 0 ;
35339 char * kwnames[] = {
35340 (char *) "self",(char *) "font", NULL
35341 };
35342
35343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35345 if (!SWIG_IsOK(res1)) {
35346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35347 }
35348 arg1 = reinterpret_cast< wxWindow * >(argp1);
35349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35350 if (!SWIG_IsOK(res2)) {
35351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35352 }
35353 if (!argp2) {
35354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35355 }
35356 arg2 = reinterpret_cast< wxFont * >(argp2);
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 (arg1)->SetOwnFont((wxFont const &)*arg2);
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_Py_Void();
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35371 PyObject *resultobj = 0;
35372 wxWindow *arg1 = (wxWindow *) 0 ;
35373 wxFont result;
35374 void *argp1 = 0 ;
35375 int res1 = 0 ;
35376 PyObject *swig_obj[1] ;
35377
35378 if (!args) SWIG_fail;
35379 swig_obj[0] = args;
35380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35381 if (!SWIG_IsOK(res1)) {
35382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35383 }
35384 arg1 = reinterpret_cast< wxWindow * >(argp1);
35385 {
35386 PyThreadState* __tstate = wxPyBeginAllowThreads();
35387 result = (arg1)->GetFont();
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj = 0;
35400 wxWindow *arg1 = (wxWindow *) 0 ;
35401 wxCaret *arg2 = (wxCaret *) 0 ;
35402 void *argp1 = 0 ;
35403 int res1 = 0 ;
35404 int res2 = 0 ;
35405 PyObject * obj0 = 0 ;
35406 PyObject * obj1 = 0 ;
35407 char * kwnames[] = {
35408 (char *) "self",(char *) "caret", NULL
35409 };
35410
35411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35413 if (!SWIG_IsOK(res1)) {
35414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35415 }
35416 arg1 = reinterpret_cast< wxWindow * >(argp1);
35417 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35418 if (!SWIG_IsOK(res2)) {
35419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35420 }
35421 {
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 (arg1)->SetCaret(arg2);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = SWIG_Py_Void();
35428 return resultobj;
35429 fail:
35430 return NULL;
35431 }
35432
35433
35434 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35435 PyObject *resultobj = 0;
35436 wxWindow *arg1 = (wxWindow *) 0 ;
35437 wxCaret *result = 0 ;
35438 void *argp1 = 0 ;
35439 int res1 = 0 ;
35440 PyObject *swig_obj[1] ;
35441
35442 if (!args) SWIG_fail;
35443 swig_obj[0] = args;
35444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35445 if (!SWIG_IsOK(res1)) {
35446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35447 }
35448 arg1 = reinterpret_cast< wxWindow * >(argp1);
35449 {
35450 PyThreadState* __tstate = wxPyBeginAllowThreads();
35451 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35452 wxPyEndAllowThreads(__tstate);
35453 if (PyErr_Occurred()) SWIG_fail;
35454 }
35455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35456 return resultobj;
35457 fail:
35458 return NULL;
35459 }
35460
35461
35462 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35463 PyObject *resultobj = 0;
35464 wxWindow *arg1 = (wxWindow *) 0 ;
35465 int result;
35466 void *argp1 = 0 ;
35467 int res1 = 0 ;
35468 PyObject *swig_obj[1] ;
35469
35470 if (!args) SWIG_fail;
35471 swig_obj[0] = args;
35472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35473 if (!SWIG_IsOK(res1)) {
35474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35475 }
35476 arg1 = reinterpret_cast< wxWindow * >(argp1);
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35480 wxPyEndAllowThreads(__tstate);
35481 if (PyErr_Occurred()) SWIG_fail;
35482 }
35483 resultobj = SWIG_From_int(static_cast< int >(result));
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35491 PyObject *resultobj = 0;
35492 wxWindow *arg1 = (wxWindow *) 0 ;
35493 int result;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 PyObject *swig_obj[1] ;
35497
35498 if (!args) SWIG_fail;
35499 swig_obj[0] = args;
35500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35503 }
35504 arg1 = reinterpret_cast< wxWindow * >(argp1);
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 resultobj = SWIG_From_int(static_cast< int >(result));
35512 return resultobj;
35513 fail:
35514 return NULL;
35515 }
35516
35517
35518 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35519 PyObject *resultobj = 0;
35520 wxWindow *arg1 = (wxWindow *) 0 ;
35521 wxString *arg2 = 0 ;
35522 int *arg3 = (int *) 0 ;
35523 int *arg4 = (int *) 0 ;
35524 void *argp1 = 0 ;
35525 int res1 = 0 ;
35526 bool temp2 = false ;
35527 int temp3 ;
35528 int res3 = SWIG_TMPOBJ ;
35529 int temp4 ;
35530 int res4 = SWIG_TMPOBJ ;
35531 PyObject * obj0 = 0 ;
35532 PyObject * obj1 = 0 ;
35533 char * kwnames[] = {
35534 (char *) "self",(char *) "string", NULL
35535 };
35536
35537 arg3 = &temp3;
35538 arg4 = &temp4;
35539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35541 if (!SWIG_IsOK(res1)) {
35542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35543 }
35544 arg1 = reinterpret_cast< wxWindow * >(argp1);
35545 {
35546 arg2 = wxString_in_helper(obj1);
35547 if (arg2 == NULL) SWIG_fail;
35548 temp2 = true;
35549 }
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 resultobj = SWIG_Py_Void();
35557 if (SWIG_IsTmpObj(res3)) {
35558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35559 } else {
35560 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35562 }
35563 if (SWIG_IsTmpObj(res4)) {
35564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35565 } else {
35566 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35567 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35568 }
35569 {
35570 if (temp2)
35571 delete arg2;
35572 }
35573 return resultobj;
35574 fail:
35575 {
35576 if (temp2)
35577 delete arg2;
35578 }
35579 return NULL;
35580 }
35581
35582
35583 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj = 0;
35585 wxWindow *arg1 = (wxWindow *) 0 ;
35586 wxString *arg2 = 0 ;
35587 int *arg3 = (int *) 0 ;
35588 int *arg4 = (int *) 0 ;
35589 int *arg5 = (int *) 0 ;
35590 int *arg6 = (int *) 0 ;
35591 wxFont *arg7 = (wxFont *) NULL ;
35592 void *argp1 = 0 ;
35593 int res1 = 0 ;
35594 bool temp2 = false ;
35595 int temp3 ;
35596 int res3 = SWIG_TMPOBJ ;
35597 int temp4 ;
35598 int res4 = SWIG_TMPOBJ ;
35599 int temp5 ;
35600 int res5 = SWIG_TMPOBJ ;
35601 int temp6 ;
35602 int res6 = SWIG_TMPOBJ ;
35603 void *argp7 = 0 ;
35604 int res7 = 0 ;
35605 PyObject * obj0 = 0 ;
35606 PyObject * obj1 = 0 ;
35607 PyObject * obj2 = 0 ;
35608 char * kwnames[] = {
35609 (char *) "self",(char *) "string",(char *) "font", NULL
35610 };
35611
35612 arg3 = &temp3;
35613 arg4 = &temp4;
35614 arg5 = &temp5;
35615 arg6 = &temp6;
35616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35618 if (!SWIG_IsOK(res1)) {
35619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35620 }
35621 arg1 = reinterpret_cast< wxWindow * >(argp1);
35622 {
35623 arg2 = wxString_in_helper(obj1);
35624 if (arg2 == NULL) SWIG_fail;
35625 temp2 = true;
35626 }
35627 if (obj2) {
35628 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35629 if (!SWIG_IsOK(res7)) {
35630 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35631 }
35632 arg7 = reinterpret_cast< wxFont * >(argp7);
35633 }
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 resultobj = SWIG_Py_Void();
35641 if (SWIG_IsTmpObj(res3)) {
35642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35643 } else {
35644 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35646 }
35647 if (SWIG_IsTmpObj(res4)) {
35648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35649 } else {
35650 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35652 }
35653 if (SWIG_IsTmpObj(res5)) {
35654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35655 } else {
35656 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35658 }
35659 if (SWIG_IsTmpObj(res6)) {
35660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35661 } else {
35662 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35664 }
35665 {
35666 if (temp2)
35667 delete arg2;
35668 }
35669 return resultobj;
35670 fail:
35671 {
35672 if (temp2)
35673 delete arg2;
35674 }
35675 return NULL;
35676 }
35677
35678
35679 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35680 PyObject *resultobj = 0;
35681 wxWindow *arg1 = (wxWindow *) 0 ;
35682 int *arg2 = (int *) 0 ;
35683 int *arg3 = (int *) 0 ;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 int temp2 ;
35687 int res2 = 0 ;
35688 int temp3 ;
35689 int res3 = 0 ;
35690 PyObject * obj0 = 0 ;
35691 PyObject * obj1 = 0 ;
35692 PyObject * obj2 = 0 ;
35693 char * kwnames[] = {
35694 (char *) "self",(char *) "x",(char *) "y", NULL
35695 };
35696
35697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35699 if (!SWIG_IsOK(res1)) {
35700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35701 }
35702 arg1 = reinterpret_cast< wxWindow * >(argp1);
35703 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35704 int val;
35705 int ecode = SWIG_AsVal_int(obj1, &val);
35706 if (!SWIG_IsOK(ecode)) {
35707 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35708 }
35709 temp2 = static_cast< int >(val);
35710 arg2 = &temp2;
35711 res2 = SWIG_AddTmpMask(ecode);
35712 }
35713 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35714 int val;
35715 int ecode = SWIG_AsVal_int(obj2, &val);
35716 if (!SWIG_IsOK(ecode)) {
35717 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35718 }
35719 temp3 = static_cast< int >(val);
35720 arg3 = &temp3;
35721 res3 = SWIG_AddTmpMask(ecode);
35722 }
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 resultobj = SWIG_Py_Void();
35730 if (SWIG_IsTmpObj(res2)) {
35731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35732 } else {
35733 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35735 }
35736 if (SWIG_IsTmpObj(res3)) {
35737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35738 } else {
35739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35741 }
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35749 PyObject *resultobj = 0;
35750 wxWindow *arg1 = (wxWindow *) 0 ;
35751 int *arg2 = (int *) 0 ;
35752 int *arg3 = (int *) 0 ;
35753 void *argp1 = 0 ;
35754 int res1 = 0 ;
35755 int temp2 ;
35756 int res2 = 0 ;
35757 int temp3 ;
35758 int res3 = 0 ;
35759 PyObject * obj0 = 0 ;
35760 PyObject * obj1 = 0 ;
35761 PyObject * obj2 = 0 ;
35762 char * kwnames[] = {
35763 (char *) "self",(char *) "x",(char *) "y", NULL
35764 };
35765
35766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35768 if (!SWIG_IsOK(res1)) {
35769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35770 }
35771 arg1 = reinterpret_cast< wxWindow * >(argp1);
35772 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35773 int val;
35774 int ecode = SWIG_AsVal_int(obj1, &val);
35775 if (!SWIG_IsOK(ecode)) {
35776 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35777 }
35778 temp2 = static_cast< int >(val);
35779 arg2 = &temp2;
35780 res2 = SWIG_AddTmpMask(ecode);
35781 }
35782 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35783 int val;
35784 int ecode = SWIG_AsVal_int(obj2, &val);
35785 if (!SWIG_IsOK(ecode)) {
35786 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35787 }
35788 temp3 = static_cast< int >(val);
35789 arg3 = &temp3;
35790 res3 = SWIG_AddTmpMask(ecode);
35791 }
35792 {
35793 PyThreadState* __tstate = wxPyBeginAllowThreads();
35794 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35795 wxPyEndAllowThreads(__tstate);
35796 if (PyErr_Occurred()) SWIG_fail;
35797 }
35798 resultobj = SWIG_Py_Void();
35799 if (SWIG_IsTmpObj(res2)) {
35800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35801 } else {
35802 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35804 }
35805 if (SWIG_IsTmpObj(res3)) {
35806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35807 } else {
35808 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35810 }
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 wxPoint *arg2 = 0 ;
35821 wxPoint result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 wxPoint temp2 ;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 char * kwnames[] = {
35828 (char *) "self",(char *) "pt", NULL
35829 };
35830
35831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35833 if (!SWIG_IsOK(res1)) {
35834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35835 }
35836 arg1 = reinterpret_cast< wxWindow * >(argp1);
35837 {
35838 arg2 = &temp2;
35839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35840 }
35841 {
35842 PyThreadState* __tstate = wxPyBeginAllowThreads();
35843 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35844 wxPyEndAllowThreads(__tstate);
35845 if (PyErr_Occurred()) SWIG_fail;
35846 }
35847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj = 0;
35856 wxWindow *arg1 = (wxWindow *) 0 ;
35857 wxPoint *arg2 = 0 ;
35858 wxPoint result;
35859 void *argp1 = 0 ;
35860 int res1 = 0 ;
35861 wxPoint temp2 ;
35862 PyObject * obj0 = 0 ;
35863 PyObject * obj1 = 0 ;
35864 char * kwnames[] = {
35865 (char *) "self",(char *) "pt", NULL
35866 };
35867
35868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35872 }
35873 arg1 = reinterpret_cast< wxWindow * >(argp1);
35874 {
35875 arg2 = &temp2;
35876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35877 }
35878 {
35879 PyThreadState* __tstate = wxPyBeginAllowThreads();
35880 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35881 wxPyEndAllowThreads(__tstate);
35882 if (PyErr_Occurred()) SWIG_fail;
35883 }
35884 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj = 0;
35893 wxWindow *arg1 = (wxWindow *) 0 ;
35894 int arg2 ;
35895 int arg3 ;
35896 wxHitTest result;
35897 void *argp1 = 0 ;
35898 int res1 = 0 ;
35899 int val2 ;
35900 int ecode2 = 0 ;
35901 int val3 ;
35902 int ecode3 = 0 ;
35903 PyObject * obj0 = 0 ;
35904 PyObject * obj1 = 0 ;
35905 PyObject * obj2 = 0 ;
35906 char * kwnames[] = {
35907 (char *) "self",(char *) "x",(char *) "y", NULL
35908 };
35909
35910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35912 if (!SWIG_IsOK(res1)) {
35913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35914 }
35915 arg1 = reinterpret_cast< wxWindow * >(argp1);
35916 ecode2 = SWIG_AsVal_int(obj1, &val2);
35917 if (!SWIG_IsOK(ecode2)) {
35918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35919 }
35920 arg2 = static_cast< int >(val2);
35921 ecode3 = SWIG_AsVal_int(obj2, &val3);
35922 if (!SWIG_IsOK(ecode3)) {
35923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35924 }
35925 arg3 = static_cast< int >(val3);
35926 {
35927 PyThreadState* __tstate = wxPyBeginAllowThreads();
35928 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35929 wxPyEndAllowThreads(__tstate);
35930 if (PyErr_Occurred()) SWIG_fail;
35931 }
35932 resultobj = SWIG_From_int(static_cast< int >(result));
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35940 PyObject *resultobj = 0;
35941 wxWindow *arg1 = (wxWindow *) 0 ;
35942 wxPoint *arg2 = 0 ;
35943 wxHitTest result;
35944 void *argp1 = 0 ;
35945 int res1 = 0 ;
35946 wxPoint temp2 ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 char * kwnames[] = {
35950 (char *) "self",(char *) "pt", NULL
35951 };
35952
35953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35955 if (!SWIG_IsOK(res1)) {
35956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35957 }
35958 arg1 = reinterpret_cast< wxWindow * >(argp1);
35959 {
35960 arg2 = &temp2;
35961 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35962 }
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 resultobj = SWIG_From_int(static_cast< int >(result));
35970 return resultobj;
35971 fail:
35972 return NULL;
35973 }
35974
35975
35976 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35977 PyObject *resultobj = 0;
35978 wxWindow *arg1 = (wxWindow *) 0 ;
35979 long arg2 ;
35980 wxBorder result;
35981 void *argp1 = 0 ;
35982 int res1 = 0 ;
35983 long val2 ;
35984 int ecode2 = 0 ;
35985
35986 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35990 }
35991 arg1 = reinterpret_cast< wxWindow * >(argp1);
35992 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35993 if (!SWIG_IsOK(ecode2)) {
35994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35995 }
35996 arg2 = static_cast< long >(val2);
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 resultobj = SWIG_From_int(static_cast< int >(result));
36004 return resultobj;
36005 fail:
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36011 PyObject *resultobj = 0;
36012 wxWindow *arg1 = (wxWindow *) 0 ;
36013 wxBorder result;
36014 void *argp1 = 0 ;
36015 int res1 = 0 ;
36016
36017 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36019 if (!SWIG_IsOK(res1)) {
36020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36021 }
36022 arg1 = reinterpret_cast< wxWindow * >(argp1);
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_From_int(static_cast< int >(result));
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36037 int argc;
36038 PyObject *argv[3];
36039
36040 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36041 --argc;
36042 if (argc == 1) {
36043 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36044 }
36045 if (argc == 2) {
36046 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36047 }
36048
36049 fail:
36050 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36056 PyObject *resultobj = 0;
36057 wxWindow *arg1 = (wxWindow *) 0 ;
36058 long arg2 = (long) wxUPDATE_UI_NONE ;
36059 void *argp1 = 0 ;
36060 int res1 = 0 ;
36061 long val2 ;
36062 int ecode2 = 0 ;
36063 PyObject * obj0 = 0 ;
36064 PyObject * obj1 = 0 ;
36065 char * kwnames[] = {
36066 (char *) "self",(char *) "flags", NULL
36067 };
36068
36069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 if (obj1) {
36076 ecode2 = SWIG_AsVal_long(obj1, &val2);
36077 if (!SWIG_IsOK(ecode2)) {
36078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36079 }
36080 arg2 = static_cast< long >(val2);
36081 }
36082 {
36083 PyThreadState* __tstate = wxPyBeginAllowThreads();
36084 (arg1)->UpdateWindowUI(arg2);
36085 wxPyEndAllowThreads(__tstate);
36086 if (PyErr_Occurred()) SWIG_fail;
36087 }
36088 resultobj = SWIG_Py_Void();
36089 return resultobj;
36090 fail:
36091 return NULL;
36092 }
36093
36094
36095 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36096 PyObject *resultobj = 0;
36097 wxWindow *arg1 = (wxWindow *) 0 ;
36098 wxMenu *arg2 = (wxMenu *) 0 ;
36099 int arg3 = (int) -1 ;
36100 int arg4 = (int) -1 ;
36101 bool result;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 void *argp2 = 0 ;
36105 int res2 = 0 ;
36106 int val3 ;
36107 int ecode3 = 0 ;
36108 int val4 ;
36109 int ecode4 = 0 ;
36110 PyObject * obj0 = 0 ;
36111 PyObject * obj1 = 0 ;
36112 PyObject * obj2 = 0 ;
36113 PyObject * obj3 = 0 ;
36114 char * kwnames[] = {
36115 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36116 };
36117
36118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36120 if (!SWIG_IsOK(res1)) {
36121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36122 }
36123 arg1 = reinterpret_cast< wxWindow * >(argp1);
36124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36125 if (!SWIG_IsOK(res2)) {
36126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36127 }
36128 arg2 = reinterpret_cast< wxMenu * >(argp2);
36129 if (obj2) {
36130 ecode3 = SWIG_AsVal_int(obj2, &val3);
36131 if (!SWIG_IsOK(ecode3)) {
36132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36133 }
36134 arg3 = static_cast< int >(val3);
36135 }
36136 if (obj3) {
36137 ecode4 = SWIG_AsVal_int(obj3, &val4);
36138 if (!SWIG_IsOK(ecode4)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36140 }
36141 arg4 = static_cast< int >(val4);
36142 }
36143 {
36144 PyThreadState* __tstate = wxPyBeginAllowThreads();
36145 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36146 wxPyEndAllowThreads(__tstate);
36147 if (PyErr_Occurred()) SWIG_fail;
36148 }
36149 {
36150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36151 }
36152 return resultobj;
36153 fail:
36154 return NULL;
36155 }
36156
36157
36158 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36159 PyObject *resultobj = 0;
36160 wxWindow *arg1 = (wxWindow *) 0 ;
36161 wxMenu *arg2 = (wxMenu *) 0 ;
36162 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36163 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36164 bool result;
36165 void *argp1 = 0 ;
36166 int res1 = 0 ;
36167 void *argp2 = 0 ;
36168 int res2 = 0 ;
36169 wxPoint temp3 ;
36170 PyObject * obj0 = 0 ;
36171 PyObject * obj1 = 0 ;
36172 PyObject * obj2 = 0 ;
36173 char * kwnames[] = {
36174 (char *) "self",(char *) "menu",(char *) "pos", NULL
36175 };
36176
36177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36184 if (!SWIG_IsOK(res2)) {
36185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36186 }
36187 arg2 = reinterpret_cast< wxMenu * >(argp2);
36188 if (obj2) {
36189 {
36190 arg3 = &temp3;
36191 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36192 }
36193 }
36194 {
36195 PyThreadState* __tstate = wxPyBeginAllowThreads();
36196 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 {
36201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36202 }
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 long result;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 PyObject *swig_obj[1] ;
36216
36217 if (!args) SWIG_fail;
36218 swig_obj[0] = args;
36219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36220 if (!SWIG_IsOK(res1)) {
36221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36222 }
36223 arg1 = reinterpret_cast< wxWindow * >(argp1);
36224 {
36225 PyThreadState* __tstate = wxPyBeginAllowThreads();
36226 result = (long)wxWindow_GetHandle(arg1);
36227 wxPyEndAllowThreads(__tstate);
36228 if (PyErr_Occurred()) SWIG_fail;
36229 }
36230 resultobj = SWIG_From_long(static_cast< long >(result));
36231 return resultobj;
36232 fail:
36233 return NULL;
36234 }
36235
36236
36237 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36238 PyObject *resultobj = 0;
36239 wxWindow *arg1 = (wxWindow *) 0 ;
36240 long arg2 ;
36241 void *argp1 = 0 ;
36242 int res1 = 0 ;
36243 long val2 ;
36244 int ecode2 = 0 ;
36245 PyObject * obj0 = 0 ;
36246 PyObject * obj1 = 0 ;
36247 char * kwnames[] = {
36248 (char *) "self",(char *) "handle", NULL
36249 };
36250
36251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36253 if (!SWIG_IsOK(res1)) {
36254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36255 }
36256 arg1 = reinterpret_cast< wxWindow * >(argp1);
36257 ecode2 = SWIG_AsVal_long(obj1, &val2);
36258 if (!SWIG_IsOK(ecode2)) {
36259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36260 }
36261 arg2 = static_cast< long >(val2);
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 wxWindow_AssociateHandle(arg1,arg2);
36265 wxPyEndAllowThreads(__tstate);
36266 if (PyErr_Occurred()) SWIG_fail;
36267 }
36268 resultobj = SWIG_Py_Void();
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36276 PyObject *resultobj = 0;
36277 wxWindow *arg1 = (wxWindow *) 0 ;
36278 void *argp1 = 0 ;
36279 int res1 = 0 ;
36280 PyObject *swig_obj[1] ;
36281
36282 if (!args) SWIG_fail;
36283 swig_obj[0] = args;
36284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 (arg1)->DissociateHandle();
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 resultobj = SWIG_Py_Void();
36296 return resultobj;
36297 fail:
36298 return NULL;
36299 }
36300
36301
36302 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj = 0;
36304 wxWindow *arg1 = (wxWindow *) 0 ;
36305 wxPaintEvent *arg2 = 0 ;
36306 void *argp1 = 0 ;
36307 int res1 = 0 ;
36308 void *argp2 = 0 ;
36309 int res2 = 0 ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 char * kwnames[] = {
36313 (char *) "self",(char *) "event", NULL
36314 };
36315
36316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36318 if (!SWIG_IsOK(res1)) {
36319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36320 }
36321 arg1 = reinterpret_cast< wxWindow * >(argp1);
36322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36323 if (!SWIG_IsOK(res2)) {
36324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36325 }
36326 if (!argp2) {
36327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36328 }
36329 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36330 {
36331 PyThreadState* __tstate = wxPyBeginAllowThreads();
36332 (arg1)->OnPaint(*arg2);
36333 wxPyEndAllowThreads(__tstate);
36334 if (PyErr_Occurred()) SWIG_fail;
36335 }
36336 resultobj = SWIG_Py_Void();
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36344 PyObject *resultobj = 0;
36345 wxWindow *arg1 = (wxWindow *) 0 ;
36346 int arg2 ;
36347 bool result;
36348 void *argp1 = 0 ;
36349 int res1 = 0 ;
36350 int val2 ;
36351 int ecode2 = 0 ;
36352 PyObject * obj0 = 0 ;
36353 PyObject * obj1 = 0 ;
36354 char * kwnames[] = {
36355 (char *) "self",(char *) "orient", NULL
36356 };
36357
36358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36360 if (!SWIG_IsOK(res1)) {
36361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36362 }
36363 arg1 = reinterpret_cast< wxWindow * >(argp1);
36364 ecode2 = SWIG_AsVal_int(obj1, &val2);
36365 if (!SWIG_IsOK(ecode2)) {
36366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36367 }
36368 arg2 = static_cast< int >(val2);
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 {
36376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36377 }
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36385 PyObject *resultobj = 0;
36386 wxWindow *arg1 = (wxWindow *) 0 ;
36387 int arg2 ;
36388 int arg3 ;
36389 int arg4 ;
36390 int arg5 ;
36391 bool arg6 = (bool) true ;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 int val2 ;
36395 int ecode2 = 0 ;
36396 int val3 ;
36397 int ecode3 = 0 ;
36398 int val4 ;
36399 int ecode4 = 0 ;
36400 int val5 ;
36401 int ecode5 = 0 ;
36402 bool val6 ;
36403 int ecode6 = 0 ;
36404 PyObject * obj0 = 0 ;
36405 PyObject * obj1 = 0 ;
36406 PyObject * obj2 = 0 ;
36407 PyObject * obj3 = 0 ;
36408 PyObject * obj4 = 0 ;
36409 PyObject * obj5 = 0 ;
36410 char * kwnames[] = {
36411 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36412 };
36413
36414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36416 if (!SWIG_IsOK(res1)) {
36417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36418 }
36419 arg1 = reinterpret_cast< wxWindow * >(argp1);
36420 ecode2 = SWIG_AsVal_int(obj1, &val2);
36421 if (!SWIG_IsOK(ecode2)) {
36422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36423 }
36424 arg2 = static_cast< int >(val2);
36425 ecode3 = SWIG_AsVal_int(obj2, &val3);
36426 if (!SWIG_IsOK(ecode3)) {
36427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36428 }
36429 arg3 = static_cast< int >(val3);
36430 ecode4 = SWIG_AsVal_int(obj3, &val4);
36431 if (!SWIG_IsOK(ecode4)) {
36432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36433 }
36434 arg4 = static_cast< int >(val4);
36435 ecode5 = SWIG_AsVal_int(obj4, &val5);
36436 if (!SWIG_IsOK(ecode5)) {
36437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36438 }
36439 arg5 = static_cast< int >(val5);
36440 if (obj5) {
36441 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36442 if (!SWIG_IsOK(ecode6)) {
36443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36444 }
36445 arg6 = static_cast< bool >(val6);
36446 }
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 resultobj = SWIG_Py_Void();
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36461 PyObject *resultobj = 0;
36462 wxWindow *arg1 = (wxWindow *) 0 ;
36463 int arg2 ;
36464 int arg3 ;
36465 bool arg4 = (bool) true ;
36466 void *argp1 = 0 ;
36467 int res1 = 0 ;
36468 int val2 ;
36469 int ecode2 = 0 ;
36470 int val3 ;
36471 int ecode3 = 0 ;
36472 bool val4 ;
36473 int ecode4 = 0 ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 PyObject * obj2 = 0 ;
36477 PyObject * obj3 = 0 ;
36478 char * kwnames[] = {
36479 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36480 };
36481
36482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 ecode2 = SWIG_AsVal_int(obj1, &val2);
36489 if (!SWIG_IsOK(ecode2)) {
36490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36491 }
36492 arg2 = static_cast< int >(val2);
36493 ecode3 = SWIG_AsVal_int(obj2, &val3);
36494 if (!SWIG_IsOK(ecode3)) {
36495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36496 }
36497 arg3 = static_cast< int >(val3);
36498 if (obj3) {
36499 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36500 if (!SWIG_IsOK(ecode4)) {
36501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36502 }
36503 arg4 = static_cast< bool >(val4);
36504 }
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 (arg1)->SetScrollPos(arg2,arg3,arg4);
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 resultobj = SWIG_Py_Void();
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36519 PyObject *resultobj = 0;
36520 wxWindow *arg1 = (wxWindow *) 0 ;
36521 int arg2 ;
36522 int result;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 int val2 ;
36526 int ecode2 = 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "orientation", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 ecode2 = SWIG_AsVal_int(obj1, &val2);
36540 if (!SWIG_IsOK(ecode2)) {
36541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36542 }
36543 arg2 = static_cast< int >(val2);
36544 {
36545 PyThreadState* __tstate = wxPyBeginAllowThreads();
36546 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 resultobj = SWIG_From_int(static_cast< int >(result));
36551 return resultobj;
36552 fail:
36553 return NULL;
36554 }
36555
36556
36557 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36558 PyObject *resultobj = 0;
36559 wxWindow *arg1 = (wxWindow *) 0 ;
36560 int arg2 ;
36561 int result;
36562 void *argp1 = 0 ;
36563 int res1 = 0 ;
36564 int val2 ;
36565 int ecode2 = 0 ;
36566 PyObject * obj0 = 0 ;
36567 PyObject * obj1 = 0 ;
36568 char * kwnames[] = {
36569 (char *) "self",(char *) "orientation", NULL
36570 };
36571
36572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36574 if (!SWIG_IsOK(res1)) {
36575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36576 }
36577 arg1 = reinterpret_cast< wxWindow * >(argp1);
36578 ecode2 = SWIG_AsVal_int(obj1, &val2);
36579 if (!SWIG_IsOK(ecode2)) {
36580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36581 }
36582 arg2 = static_cast< int >(val2);
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 resultobj = SWIG_From_int(static_cast< int >(result));
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36597 PyObject *resultobj = 0;
36598 wxWindow *arg1 = (wxWindow *) 0 ;
36599 int arg2 ;
36600 int result;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603 int val2 ;
36604 int ecode2 = 0 ;
36605 PyObject * obj0 = 0 ;
36606 PyObject * obj1 = 0 ;
36607 char * kwnames[] = {
36608 (char *) "self",(char *) "orientation", NULL
36609 };
36610
36611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36613 if (!SWIG_IsOK(res1)) {
36614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36615 }
36616 arg1 = reinterpret_cast< wxWindow * >(argp1);
36617 ecode2 = SWIG_AsVal_int(obj1, &val2);
36618 if (!SWIG_IsOK(ecode2)) {
36619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36620 }
36621 arg2 = static_cast< int >(val2);
36622 {
36623 PyThreadState* __tstate = wxPyBeginAllowThreads();
36624 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 resultobj = SWIG_From_int(static_cast< int >(result));
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj = 0;
36637 wxWindow *arg1 = (wxWindow *) 0 ;
36638 int arg2 ;
36639 int arg3 ;
36640 wxRect *arg4 = (wxRect *) NULL ;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 int val2 ;
36644 int ecode2 = 0 ;
36645 int val3 ;
36646 int ecode3 = 0 ;
36647 void *argp4 = 0 ;
36648 int res4 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 PyObject * obj2 = 0 ;
36652 PyObject * obj3 = 0 ;
36653 char * kwnames[] = {
36654 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36655 };
36656
36657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36659 if (!SWIG_IsOK(res1)) {
36660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36661 }
36662 arg1 = reinterpret_cast< wxWindow * >(argp1);
36663 ecode2 = SWIG_AsVal_int(obj1, &val2);
36664 if (!SWIG_IsOK(ecode2)) {
36665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36666 }
36667 arg2 = static_cast< int >(val2);
36668 ecode3 = SWIG_AsVal_int(obj2, &val3);
36669 if (!SWIG_IsOK(ecode3)) {
36670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36671 }
36672 arg3 = static_cast< int >(val3);
36673 if (obj3) {
36674 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36675 if (!SWIG_IsOK(res4)) {
36676 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36677 }
36678 arg4 = reinterpret_cast< wxRect * >(argp4);
36679 }
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 resultobj = SWIG_Py_Void();
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj = 0;
36695 wxWindow *arg1 = (wxWindow *) 0 ;
36696 int arg2 ;
36697 bool result;
36698 void *argp1 = 0 ;
36699 int res1 = 0 ;
36700 int val2 ;
36701 int ecode2 = 0 ;
36702 PyObject * obj0 = 0 ;
36703 PyObject * obj1 = 0 ;
36704 char * kwnames[] = {
36705 (char *) "self",(char *) "lines", NULL
36706 };
36707
36708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36710 if (!SWIG_IsOK(res1)) {
36711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36712 }
36713 arg1 = reinterpret_cast< wxWindow * >(argp1);
36714 ecode2 = SWIG_AsVal_int(obj1, &val2);
36715 if (!SWIG_IsOK(ecode2)) {
36716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36717 }
36718 arg2 = static_cast< int >(val2);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (bool)(arg1)->ScrollLines(arg2);
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 {
36726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36735 PyObject *resultobj = 0;
36736 wxWindow *arg1 = (wxWindow *) 0 ;
36737 int arg2 ;
36738 bool result;
36739 void *argp1 = 0 ;
36740 int res1 = 0 ;
36741 int val2 ;
36742 int ecode2 = 0 ;
36743 PyObject * obj0 = 0 ;
36744 PyObject * obj1 = 0 ;
36745 char * kwnames[] = {
36746 (char *) "self",(char *) "pages", NULL
36747 };
36748
36749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36751 if (!SWIG_IsOK(res1)) {
36752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36753 }
36754 arg1 = reinterpret_cast< wxWindow * >(argp1);
36755 ecode2 = SWIG_AsVal_int(obj1, &val2);
36756 if (!SWIG_IsOK(ecode2)) {
36757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36758 }
36759 arg2 = static_cast< int >(val2);
36760 {
36761 PyThreadState* __tstate = wxPyBeginAllowThreads();
36762 result = (bool)(arg1)->ScrollPages(arg2);
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 {
36767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36768 }
36769 return resultobj;
36770 fail:
36771 return NULL;
36772 }
36773
36774
36775 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36776 PyObject *resultobj = 0;
36777 wxWindow *arg1 = (wxWindow *) 0 ;
36778 bool result;
36779 void *argp1 = 0 ;
36780 int res1 = 0 ;
36781 PyObject *swig_obj[1] ;
36782
36783 if (!args) SWIG_fail;
36784 swig_obj[0] = args;
36785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36786 if (!SWIG_IsOK(res1)) {
36787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36788 }
36789 arg1 = reinterpret_cast< wxWindow * >(argp1);
36790 {
36791 PyThreadState* __tstate = wxPyBeginAllowThreads();
36792 result = (bool)(arg1)->LineUp();
36793 wxPyEndAllowThreads(__tstate);
36794 if (PyErr_Occurred()) SWIG_fail;
36795 }
36796 {
36797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36798 }
36799 return resultobj;
36800 fail:
36801 return NULL;
36802 }
36803
36804
36805 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36806 PyObject *resultobj = 0;
36807 wxWindow *arg1 = (wxWindow *) 0 ;
36808 bool result;
36809 void *argp1 = 0 ;
36810 int res1 = 0 ;
36811 PyObject *swig_obj[1] ;
36812
36813 if (!args) SWIG_fail;
36814 swig_obj[0] = args;
36815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36816 if (!SWIG_IsOK(res1)) {
36817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36818 }
36819 arg1 = reinterpret_cast< wxWindow * >(argp1);
36820 {
36821 PyThreadState* __tstate = wxPyBeginAllowThreads();
36822 result = (bool)(arg1)->LineDown();
36823 wxPyEndAllowThreads(__tstate);
36824 if (PyErr_Occurred()) SWIG_fail;
36825 }
36826 {
36827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36828 }
36829 return resultobj;
36830 fail:
36831 return NULL;
36832 }
36833
36834
36835 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36836 PyObject *resultobj = 0;
36837 wxWindow *arg1 = (wxWindow *) 0 ;
36838 bool result;
36839 void *argp1 = 0 ;
36840 int res1 = 0 ;
36841 PyObject *swig_obj[1] ;
36842
36843 if (!args) SWIG_fail;
36844 swig_obj[0] = args;
36845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36846 if (!SWIG_IsOK(res1)) {
36847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36848 }
36849 arg1 = reinterpret_cast< wxWindow * >(argp1);
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 result = (bool)(arg1)->PageUp();
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 {
36857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36858 }
36859 return resultobj;
36860 fail:
36861 return NULL;
36862 }
36863
36864
36865 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36866 PyObject *resultobj = 0;
36867 wxWindow *arg1 = (wxWindow *) 0 ;
36868 bool result;
36869 void *argp1 = 0 ;
36870 int res1 = 0 ;
36871 PyObject *swig_obj[1] ;
36872
36873 if (!args) SWIG_fail;
36874 swig_obj[0] = args;
36875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36876 if (!SWIG_IsOK(res1)) {
36877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36878 }
36879 arg1 = reinterpret_cast< wxWindow * >(argp1);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 result = (bool)(arg1)->PageDown();
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 {
36887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36888 }
36889 return resultobj;
36890 fail:
36891 return NULL;
36892 }
36893
36894
36895 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36896 PyObject *resultobj = 0;
36897 wxWindow *arg1 = (wxWindow *) 0 ;
36898 wxString *arg2 = 0 ;
36899 void *argp1 = 0 ;
36900 int res1 = 0 ;
36901 bool temp2 = false ;
36902 PyObject * obj0 = 0 ;
36903 PyObject * obj1 = 0 ;
36904 char * kwnames[] = {
36905 (char *) "self",(char *) "text", NULL
36906 };
36907
36908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 arg2 = wxString_in_helper(obj1);
36916 if (arg2 == NULL) SWIG_fail;
36917 temp2 = true;
36918 }
36919 {
36920 PyThreadState* __tstate = wxPyBeginAllowThreads();
36921 (arg1)->SetHelpText((wxString const &)*arg2);
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 resultobj = SWIG_Py_Void();
36926 {
36927 if (temp2)
36928 delete arg2;
36929 }
36930 return resultobj;
36931 fail:
36932 {
36933 if (temp2)
36934 delete arg2;
36935 }
36936 return NULL;
36937 }
36938
36939
36940 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj = 0;
36942 wxWindow *arg1 = (wxWindow *) 0 ;
36943 wxString *arg2 = 0 ;
36944 void *argp1 = 0 ;
36945 int res1 = 0 ;
36946 bool temp2 = false ;
36947 PyObject * obj0 = 0 ;
36948 PyObject * obj1 = 0 ;
36949 char * kwnames[] = {
36950 (char *) "self",(char *) "text", NULL
36951 };
36952
36953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36955 if (!SWIG_IsOK(res1)) {
36956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36957 }
36958 arg1 = reinterpret_cast< wxWindow * >(argp1);
36959 {
36960 arg2 = wxString_in_helper(obj1);
36961 if (arg2 == NULL) SWIG_fail;
36962 temp2 = true;
36963 }
36964 {
36965 PyThreadState* __tstate = wxPyBeginAllowThreads();
36966 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_Py_Void();
36971 {
36972 if (temp2)
36973 delete arg2;
36974 }
36975 return resultobj;
36976 fail:
36977 {
36978 if (temp2)
36979 delete arg2;
36980 }
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj = 0;
36987 wxWindow *arg1 = (wxWindow *) 0 ;
36988 wxPoint *arg2 = 0 ;
36989 wxHelpEvent::Origin arg3 ;
36990 wxString result;
36991 void *argp1 = 0 ;
36992 int res1 = 0 ;
36993 wxPoint temp2 ;
36994 void *argp3 ;
36995 int res3 = 0 ;
36996 PyObject * obj0 = 0 ;
36997 PyObject * obj1 = 0 ;
36998 PyObject * obj2 = 0 ;
36999 char * kwnames[] = {
37000 (char *) "self",(char *) "pt",(char *) "origin", NULL
37001 };
37002
37003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37005 if (!SWIG_IsOK(res1)) {
37006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37007 }
37008 arg1 = reinterpret_cast< wxWindow * >(argp1);
37009 {
37010 arg2 = &temp2;
37011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37012 }
37013 {
37014 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37015 if (!SWIG_IsOK(res3)) {
37016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37017 }
37018 if (!argp3) {
37019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37020 } else {
37021 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37022 arg3 = *temp;
37023 if (SWIG_IsNewObj(res3)) delete temp;
37024 }
37025 }
37026 {
37027 PyThreadState* __tstate = wxPyBeginAllowThreads();
37028 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37029 wxPyEndAllowThreads(__tstate);
37030 if (PyErr_Occurred()) SWIG_fail;
37031 }
37032 {
37033 #if wxUSE_UNICODE
37034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37035 #else
37036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37037 #endif
37038 }
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37046 PyObject *resultobj = 0;
37047 wxWindow *arg1 = (wxWindow *) 0 ;
37048 wxString result;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051 PyObject *swig_obj[1] ;
37052
37053 if (!args) SWIG_fail;
37054 swig_obj[0] = args;
37055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37056 if (!SWIG_IsOK(res1)) {
37057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37058 }
37059 arg1 = reinterpret_cast< wxWindow * >(argp1);
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 result = ((wxWindow const *)arg1)->GetHelpText();
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 {
37067 #if wxUSE_UNICODE
37068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37069 #else
37070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37071 #endif
37072 }
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 wxString *arg2 = 0 ;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 bool temp2 = false ;
37086 PyObject * obj0 = 0 ;
37087 PyObject * obj1 = 0 ;
37088 char * kwnames[] = {
37089 (char *) "self",(char *) "tip", NULL
37090 };
37091
37092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37094 if (!SWIG_IsOK(res1)) {
37095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37096 }
37097 arg1 = reinterpret_cast< wxWindow * >(argp1);
37098 {
37099 arg2 = wxString_in_helper(obj1);
37100 if (arg2 == NULL) SWIG_fail;
37101 temp2 = true;
37102 }
37103 {
37104 PyThreadState* __tstate = wxPyBeginAllowThreads();
37105 (arg1)->SetToolTip((wxString const &)*arg2);
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 resultobj = SWIG_Py_Void();
37110 {
37111 if (temp2)
37112 delete arg2;
37113 }
37114 return resultobj;
37115 fail:
37116 {
37117 if (temp2)
37118 delete arg2;
37119 }
37120 return NULL;
37121 }
37122
37123
37124 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj = 0;
37126 wxWindow *arg1 = (wxWindow *) 0 ;
37127 wxToolTip *arg2 = (wxToolTip *) 0 ;
37128 void *argp1 = 0 ;
37129 int res1 = 0 ;
37130 int res2 = 0 ;
37131 PyObject * obj0 = 0 ;
37132 PyObject * obj1 = 0 ;
37133 char * kwnames[] = {
37134 (char *) "self",(char *) "tip", NULL
37135 };
37136
37137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37139 if (!SWIG_IsOK(res1)) {
37140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37141 }
37142 arg1 = reinterpret_cast< wxWindow * >(argp1);
37143 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37144 if (!SWIG_IsOK(res2)) {
37145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37146 }
37147 {
37148 PyThreadState* __tstate = wxPyBeginAllowThreads();
37149 (arg1)->SetToolTip(arg2);
37150 wxPyEndAllowThreads(__tstate);
37151 if (PyErr_Occurred()) SWIG_fail;
37152 }
37153 resultobj = SWIG_Py_Void();
37154 return resultobj;
37155 fail:
37156 return NULL;
37157 }
37158
37159
37160 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37161 PyObject *resultobj = 0;
37162 wxWindow *arg1 = (wxWindow *) 0 ;
37163 wxToolTip *result = 0 ;
37164 void *argp1 = 0 ;
37165 int res1 = 0 ;
37166 PyObject *swig_obj[1] ;
37167
37168 if (!args) SWIG_fail;
37169 swig_obj[0] = args;
37170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37171 if (!SWIG_IsOK(res1)) {
37172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37173 }
37174 arg1 = reinterpret_cast< wxWindow * >(argp1);
37175 {
37176 PyThreadState* __tstate = wxPyBeginAllowThreads();
37177 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 {
37182 resultobj = wxPyMake_wxObject(result, (bool)0);
37183 }
37184 return resultobj;
37185 fail:
37186 return NULL;
37187 }
37188
37189
37190 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37191 PyObject *resultobj = 0;
37192 wxWindow *arg1 = (wxWindow *) 0 ;
37193 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37194 void *argp1 = 0 ;
37195 int res1 = 0 ;
37196 int res2 = 0 ;
37197 PyObject * obj0 = 0 ;
37198 PyObject * obj1 = 0 ;
37199 char * kwnames[] = {
37200 (char *) "self",(char *) "dropTarget", NULL
37201 };
37202
37203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37205 if (!SWIG_IsOK(res1)) {
37206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37207 }
37208 arg1 = reinterpret_cast< wxWindow * >(argp1);
37209 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37210 if (!SWIG_IsOK(res2)) {
37211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37212 }
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 (arg1)->SetDropTarget(arg2);
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 resultobj = SWIG_Py_Void();
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37227 PyObject *resultobj = 0;
37228 wxWindow *arg1 = (wxWindow *) 0 ;
37229 wxPyDropTarget *result = 0 ;
37230 void *argp1 = 0 ;
37231 int res1 = 0 ;
37232 PyObject *swig_obj[1] ;
37233
37234 if (!args) SWIG_fail;
37235 swig_obj[0] = args;
37236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37237 if (!SWIG_IsOK(res1)) {
37238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37239 }
37240 arg1 = reinterpret_cast< wxWindow * >(argp1);
37241 {
37242 PyThreadState* __tstate = wxPyBeginAllowThreads();
37243 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj = 0;
37256 wxWindow *arg1 = (wxWindow *) 0 ;
37257 bool arg2 ;
37258 void *argp1 = 0 ;
37259 int res1 = 0 ;
37260 bool val2 ;
37261 int ecode2 = 0 ;
37262 PyObject * obj0 = 0 ;
37263 PyObject * obj1 = 0 ;
37264 char * kwnames[] = {
37265 (char *) "self",(char *) "accept", NULL
37266 };
37267
37268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37270 if (!SWIG_IsOK(res1)) {
37271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37272 }
37273 arg1 = reinterpret_cast< wxWindow * >(argp1);
37274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37275 if (!SWIG_IsOK(ecode2)) {
37276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37277 }
37278 arg2 = static_cast< bool >(val2);
37279 {
37280 PyThreadState* __tstate = wxPyBeginAllowThreads();
37281 (arg1)->DragAcceptFiles(arg2);
37282 wxPyEndAllowThreads(__tstate);
37283 if (PyErr_Occurred()) SWIG_fail;
37284 }
37285 resultobj = SWIG_Py_Void();
37286 return resultobj;
37287 fail:
37288 return NULL;
37289 }
37290
37291
37292 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37293 PyObject *resultobj = 0;
37294 wxWindow *arg1 = (wxWindow *) 0 ;
37295 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 int res2 = 0 ;
37299 PyObject * obj0 = 0 ;
37300 PyObject * obj1 = 0 ;
37301 char * kwnames[] = {
37302 (char *) "self",(char *) "constraints", NULL
37303 };
37304
37305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37312 if (!SWIG_IsOK(res2)) {
37313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37314 }
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 (arg1)->SetConstraints(arg2);
37318 wxPyEndAllowThreads(__tstate);
37319 if (PyErr_Occurred()) SWIG_fail;
37320 }
37321 resultobj = SWIG_Py_Void();
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 wxLayoutConstraints *result = 0 ;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 PyObject *swig_obj[1] ;
37335
37336 if (!args) SWIG_fail;
37337 swig_obj[0] = args;
37338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res1)) {
37340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37341 }
37342 arg1 = reinterpret_cast< wxWindow * >(argp1);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37357 PyObject *resultobj = 0;
37358 wxWindow *arg1 = (wxWindow *) 0 ;
37359 bool arg2 ;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 bool val2 ;
37363 int ecode2 = 0 ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 char * kwnames[] = {
37367 (char *) "self",(char *) "autoLayout", NULL
37368 };
37369
37370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37372 if (!SWIG_IsOK(res1)) {
37373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37374 }
37375 arg1 = reinterpret_cast< wxWindow * >(argp1);
37376 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37377 if (!SWIG_IsOK(ecode2)) {
37378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37379 }
37380 arg2 = static_cast< bool >(val2);
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 (arg1)->SetAutoLayout(arg2);
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_Py_Void();
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 bool result;
37398 void *argp1 = 0 ;
37399 int res1 = 0 ;
37400 PyObject *swig_obj[1] ;
37401
37402 if (!args) SWIG_fail;
37403 swig_obj[0] = args;
37404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37407 }
37408 arg1 = reinterpret_cast< wxWindow * >(argp1);
37409 {
37410 PyThreadState* __tstate = wxPyBeginAllowThreads();
37411 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 {
37416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37417 }
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxWindow *arg1 = (wxWindow *) 0 ;
37427 bool result;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (bool)(arg1)->Layout();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 {
37446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37447 }
37448 return resultobj;
37449 fail:
37450 return NULL;
37451 }
37452
37453
37454 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37455 PyObject *resultobj = 0;
37456 wxWindow *arg1 = (wxWindow *) 0 ;
37457 wxSizer *arg2 = (wxSizer *) 0 ;
37458 bool arg3 = (bool) true ;
37459 void *argp1 = 0 ;
37460 int res1 = 0 ;
37461 int res2 = 0 ;
37462 bool val3 ;
37463 int ecode3 = 0 ;
37464 PyObject * obj0 = 0 ;
37465 PyObject * obj1 = 0 ;
37466 PyObject * obj2 = 0 ;
37467 char * kwnames[] = {
37468 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37469 };
37470
37471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37478 if (!SWIG_IsOK(res2)) {
37479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37480 }
37481 if (obj2) {
37482 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37483 if (!SWIG_IsOK(ecode3)) {
37484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37485 }
37486 arg3 = static_cast< bool >(val3);
37487 }
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 (arg1)->SetSizer(arg2,arg3);
37491 wxPyEndAllowThreads(__tstate);
37492 if (PyErr_Occurred()) SWIG_fail;
37493 }
37494 resultobj = SWIG_Py_Void();
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj = 0;
37503 wxWindow *arg1 = (wxWindow *) 0 ;
37504 wxSizer *arg2 = (wxSizer *) 0 ;
37505 bool arg3 = (bool) true ;
37506 void *argp1 = 0 ;
37507 int res1 = 0 ;
37508 int res2 = 0 ;
37509 bool val3 ;
37510 int ecode3 = 0 ;
37511 PyObject * obj0 = 0 ;
37512 PyObject * obj1 = 0 ;
37513 PyObject * obj2 = 0 ;
37514 char * kwnames[] = {
37515 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37516 };
37517
37518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37520 if (!SWIG_IsOK(res1)) {
37521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37522 }
37523 arg1 = reinterpret_cast< wxWindow * >(argp1);
37524 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37525 if (!SWIG_IsOK(res2)) {
37526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37527 }
37528 if (obj2) {
37529 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37530 if (!SWIG_IsOK(ecode3)) {
37531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37532 }
37533 arg3 = static_cast< bool >(val3);
37534 }
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 (arg1)->SetSizerAndFit(arg2,arg3);
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = SWIG_Py_Void();
37542 return resultobj;
37543 fail:
37544 return NULL;
37545 }
37546
37547
37548 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37549 PyObject *resultobj = 0;
37550 wxWindow *arg1 = (wxWindow *) 0 ;
37551 wxSizer *result = 0 ;
37552 void *argp1 = 0 ;
37553 int res1 = 0 ;
37554 PyObject *swig_obj[1] ;
37555
37556 if (!args) SWIG_fail;
37557 swig_obj[0] = args;
37558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37559 if (!SWIG_IsOK(res1)) {
37560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37561 }
37562 arg1 = reinterpret_cast< wxWindow * >(argp1);
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37566 wxPyEndAllowThreads(__tstate);
37567 if (PyErr_Occurred()) SWIG_fail;
37568 }
37569 {
37570 resultobj = wxPyMake_wxObject(result, (bool)0);
37571 }
37572 return resultobj;
37573 fail:
37574 return NULL;
37575 }
37576
37577
37578 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37579 PyObject *resultobj = 0;
37580 wxWindow *arg1 = (wxWindow *) 0 ;
37581 wxSizer *arg2 = (wxSizer *) 0 ;
37582 void *argp1 = 0 ;
37583 int res1 = 0 ;
37584 void *argp2 = 0 ;
37585 int res2 = 0 ;
37586 PyObject * obj0 = 0 ;
37587 PyObject * obj1 = 0 ;
37588 char * kwnames[] = {
37589 (char *) "self",(char *) "sizer", NULL
37590 };
37591
37592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37594 if (!SWIG_IsOK(res1)) {
37595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37596 }
37597 arg1 = reinterpret_cast< wxWindow * >(argp1);
37598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37599 if (!SWIG_IsOK(res2)) {
37600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37601 }
37602 arg2 = reinterpret_cast< wxSizer * >(argp2);
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 (arg1)->SetContainingSizer(arg2);
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 resultobj = SWIG_Py_Void();
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37617 PyObject *resultobj = 0;
37618 wxWindow *arg1 = (wxWindow *) 0 ;
37619 wxSizer *result = 0 ;
37620 void *argp1 = 0 ;
37621 int res1 = 0 ;
37622 PyObject *swig_obj[1] ;
37623
37624 if (!args) SWIG_fail;
37625 swig_obj[0] = args;
37626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37627 if (!SWIG_IsOK(res1)) {
37628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37629 }
37630 arg1 = reinterpret_cast< wxWindow * >(argp1);
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37634 wxPyEndAllowThreads(__tstate);
37635 if (PyErr_Occurred()) SWIG_fail;
37636 }
37637 {
37638 resultobj = wxPyMake_wxObject(result, (bool)0);
37639 }
37640 return resultobj;
37641 fail:
37642 return NULL;
37643 }
37644
37645
37646 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37647 PyObject *resultobj = 0;
37648 wxWindow *arg1 = (wxWindow *) 0 ;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 PyObject *swig_obj[1] ;
37652
37653 if (!args) SWIG_fail;
37654 swig_obj[0] = args;
37655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37656 if (!SWIG_IsOK(res1)) {
37657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37658 }
37659 arg1 = reinterpret_cast< wxWindow * >(argp1);
37660 {
37661 PyThreadState* __tstate = wxPyBeginAllowThreads();
37662 (arg1)->InheritAttributes();
37663 wxPyEndAllowThreads(__tstate);
37664 if (PyErr_Occurred()) SWIG_fail;
37665 }
37666 resultobj = SWIG_Py_Void();
37667 return resultobj;
37668 fail:
37669 return NULL;
37670 }
37671
37672
37673 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37674 PyObject *resultobj = 0;
37675 wxWindow *arg1 = (wxWindow *) 0 ;
37676 bool result;
37677 void *argp1 = 0 ;
37678 int res1 = 0 ;
37679 PyObject *swig_obj[1] ;
37680
37681 if (!args) SWIG_fail;
37682 swig_obj[0] = args;
37683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37684 if (!SWIG_IsOK(res1)) {
37685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37686 }
37687 arg1 = reinterpret_cast< wxWindow * >(argp1);
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 {
37695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37696 }
37697 return resultobj;
37698 fail:
37699 return NULL;
37700 }
37701
37702
37703 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37704 PyObject *obj;
37705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37706 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37707 return SWIG_Py_Void();
37708 }
37709
37710 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37711 return SWIG_Python_InitShadowInstance(args);
37712 }
37713
37714 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37715 PyObject *resultobj = 0;
37716 long arg1 ;
37717 wxWindow *arg2 = (wxWindow *) NULL ;
37718 wxWindow *result = 0 ;
37719 long val1 ;
37720 int ecode1 = 0 ;
37721 void *argp2 = 0 ;
37722 int res2 = 0 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "id",(char *) "parent", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37730 ecode1 = SWIG_AsVal_long(obj0, &val1);
37731 if (!SWIG_IsOK(ecode1)) {
37732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37733 }
37734 arg1 = static_cast< long >(val1);
37735 if (obj1) {
37736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37737 if (!SWIG_IsOK(res2)) {
37738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37739 }
37740 arg2 = reinterpret_cast< wxWindow * >(argp2);
37741 }
37742 {
37743 if (!wxPyCheckForApp()) SWIG_fail;
37744 PyThreadState* __tstate = wxPyBeginAllowThreads();
37745 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37746 wxPyEndAllowThreads(__tstate);
37747 if (PyErr_Occurred()) SWIG_fail;
37748 }
37749 {
37750 resultobj = wxPyMake_wxObject(result, 0);
37751 }
37752 return resultobj;
37753 fail:
37754 return NULL;
37755 }
37756
37757
37758 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37759 PyObject *resultobj = 0;
37760 wxString *arg1 = 0 ;
37761 wxWindow *arg2 = (wxWindow *) NULL ;
37762 wxWindow *result = 0 ;
37763 bool temp1 = false ;
37764 void *argp2 = 0 ;
37765 int res2 = 0 ;
37766 PyObject * obj0 = 0 ;
37767 PyObject * obj1 = 0 ;
37768 char * kwnames[] = {
37769 (char *) "name",(char *) "parent", NULL
37770 };
37771
37772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37773 {
37774 arg1 = wxString_in_helper(obj0);
37775 if (arg1 == NULL) SWIG_fail;
37776 temp1 = true;
37777 }
37778 if (obj1) {
37779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37780 if (!SWIG_IsOK(res2)) {
37781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37782 }
37783 arg2 = reinterpret_cast< wxWindow * >(argp2);
37784 }
37785 {
37786 if (!wxPyCheckForApp()) SWIG_fail;
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37789 wxPyEndAllowThreads(__tstate);
37790 if (PyErr_Occurred()) SWIG_fail;
37791 }
37792 {
37793 resultobj = wxPyMake_wxObject(result, 0);
37794 }
37795 {
37796 if (temp1)
37797 delete arg1;
37798 }
37799 return resultobj;
37800 fail:
37801 {
37802 if (temp1)
37803 delete arg1;
37804 }
37805 return NULL;
37806 }
37807
37808
37809 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37810 PyObject *resultobj = 0;
37811 wxString *arg1 = 0 ;
37812 wxWindow *arg2 = (wxWindow *) NULL ;
37813 wxWindow *result = 0 ;
37814 bool temp1 = false ;
37815 void *argp2 = 0 ;
37816 int res2 = 0 ;
37817 PyObject * obj0 = 0 ;
37818 PyObject * obj1 = 0 ;
37819 char * kwnames[] = {
37820 (char *) "label",(char *) "parent", NULL
37821 };
37822
37823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37824 {
37825 arg1 = wxString_in_helper(obj0);
37826 if (arg1 == NULL) SWIG_fail;
37827 temp1 = true;
37828 }
37829 if (obj1) {
37830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res2)) {
37832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37833 }
37834 arg2 = reinterpret_cast< wxWindow * >(argp2);
37835 }
37836 {
37837 if (!wxPyCheckForApp()) SWIG_fail;
37838 PyThreadState* __tstate = wxPyBeginAllowThreads();
37839 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = wxPyMake_wxObject(result, 0);
37845 }
37846 {
37847 if (temp1)
37848 delete arg1;
37849 }
37850 return resultobj;
37851 fail:
37852 {
37853 if (temp1)
37854 delete arg1;
37855 }
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj = 0;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 unsigned long arg2 ;
37864 wxWindow *result = 0 ;
37865 void *argp1 = 0 ;
37866 int res1 = 0 ;
37867 unsigned long val2 ;
37868 int ecode2 = 0 ;
37869 PyObject * obj0 = 0 ;
37870 PyObject * obj1 = 0 ;
37871 char * kwnames[] = {
37872 (char *) "parent",(char *) "_hWnd", NULL
37873 };
37874
37875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37877 if (!SWIG_IsOK(res1)) {
37878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37879 }
37880 arg1 = reinterpret_cast< wxWindow * >(argp1);
37881 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37882 if (!SWIG_IsOK(ecode2)) {
37883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37884 }
37885 arg2 = static_cast< unsigned long >(val2);
37886 {
37887 PyThreadState* __tstate = wxPyBeginAllowThreads();
37888 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 {
37893 resultobj = wxPyMake_wxObject(result, 0);
37894 }
37895 return resultobj;
37896 fail:
37897 return NULL;
37898 }
37899
37900
37901 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37902 PyObject *resultobj = 0;
37903 PyObject *result = 0 ;
37904
37905 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 result = (PyObject *)GetTopLevelWindows();
37909 wxPyEndAllowThreads(__tstate);
37910 if (PyErr_Occurred()) SWIG_fail;
37911 }
37912 resultobj = result;
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *resultobj = 0;
37921 wxValidator *result = 0 ;
37922
37923 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (wxValidator *)new wxValidator();
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37938 PyObject *resultobj = 0;
37939 wxValidator *arg1 = (wxValidator *) 0 ;
37940 wxValidator *result = 0 ;
37941 void *argp1 = 0 ;
37942 int res1 = 0 ;
37943 PyObject *swig_obj[1] ;
37944
37945 if (!args) SWIG_fail;
37946 swig_obj[0] = args;
37947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37948 if (!SWIG_IsOK(res1)) {
37949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37950 }
37951 arg1 = reinterpret_cast< wxValidator * >(argp1);
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 result = (wxValidator *)(arg1)->Clone();
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 {
37959 resultobj = wxPyMake_wxObject(result, 0);
37960 }
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj = 0;
37969 wxValidator *arg1 = (wxValidator *) 0 ;
37970 wxWindow *arg2 = (wxWindow *) 0 ;
37971 bool result;
37972 void *argp1 = 0 ;
37973 int res1 = 0 ;
37974 void *argp2 = 0 ;
37975 int res2 = 0 ;
37976 PyObject * obj0 = 0 ;
37977 PyObject * obj1 = 0 ;
37978 char * kwnames[] = {
37979 (char *) "self",(char *) "parent", NULL
37980 };
37981
37982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37984 if (!SWIG_IsOK(res1)) {
37985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37986 }
37987 arg1 = reinterpret_cast< wxValidator * >(argp1);
37988 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37989 if (!SWIG_IsOK(res2)) {
37990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37991 }
37992 arg2 = reinterpret_cast< wxWindow * >(argp2);
37993 {
37994 PyThreadState* __tstate = wxPyBeginAllowThreads();
37995 result = (bool)(arg1)->Validate(arg2);
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 {
38000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38001 }
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38009 PyObject *resultobj = 0;
38010 wxValidator *arg1 = (wxValidator *) 0 ;
38011 bool result;
38012 void *argp1 = 0 ;
38013 int res1 = 0 ;
38014 PyObject *swig_obj[1] ;
38015
38016 if (!args) SWIG_fail;
38017 swig_obj[0] = args;
38018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38019 if (!SWIG_IsOK(res1)) {
38020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38021 }
38022 arg1 = reinterpret_cast< wxValidator * >(argp1);
38023 {
38024 PyThreadState* __tstate = wxPyBeginAllowThreads();
38025 result = (bool)(arg1)->TransferToWindow();
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 {
38030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38031 }
38032 return resultobj;
38033 fail:
38034 return NULL;
38035 }
38036
38037
38038 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38039 PyObject *resultobj = 0;
38040 wxValidator *arg1 = (wxValidator *) 0 ;
38041 bool result;
38042 void *argp1 = 0 ;
38043 int res1 = 0 ;
38044 PyObject *swig_obj[1] ;
38045
38046 if (!args) SWIG_fail;
38047 swig_obj[0] = args;
38048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38049 if (!SWIG_IsOK(res1)) {
38050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38051 }
38052 arg1 = reinterpret_cast< wxValidator * >(argp1);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = (bool)(arg1)->TransferFromWindow();
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38069 PyObject *resultobj = 0;
38070 wxValidator *arg1 = (wxValidator *) 0 ;
38071 wxWindow *result = 0 ;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 PyObject *swig_obj[1] ;
38075
38076 if (!args) SWIG_fail;
38077 swig_obj[0] = args;
38078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38079 if (!SWIG_IsOK(res1)) {
38080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38081 }
38082 arg1 = reinterpret_cast< wxValidator * >(argp1);
38083 {
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = (wxWindow *)(arg1)->GetWindow();
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 resultobj = wxPyMake_wxObject(result, 0);
38091 }
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj = 0;
38100 wxValidator *arg1 = (wxValidator *) 0 ;
38101 wxWindow *arg2 = (wxWindow *) 0 ;
38102 void *argp1 = 0 ;
38103 int res1 = 0 ;
38104 void *argp2 = 0 ;
38105 int res2 = 0 ;
38106 PyObject * obj0 = 0 ;
38107 PyObject * obj1 = 0 ;
38108 char * kwnames[] = {
38109 (char *) "self",(char *) "window", NULL
38110 };
38111
38112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38114 if (!SWIG_IsOK(res1)) {
38115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38116 }
38117 arg1 = reinterpret_cast< wxValidator * >(argp1);
38118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38119 if (!SWIG_IsOK(res2)) {
38120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38121 }
38122 arg2 = reinterpret_cast< wxWindow * >(argp2);
38123 {
38124 PyThreadState* __tstate = wxPyBeginAllowThreads();
38125 (arg1)->SetWindow(arg2);
38126 wxPyEndAllowThreads(__tstate);
38127 if (PyErr_Occurred()) SWIG_fail;
38128 }
38129 resultobj = SWIG_Py_Void();
38130 return resultobj;
38131 fail:
38132 return NULL;
38133 }
38134
38135
38136 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38137 PyObject *resultobj = 0;
38138 bool result;
38139
38140 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38141 {
38142 PyThreadState* __tstate = wxPyBeginAllowThreads();
38143 result = (bool)wxValidator::IsSilent();
38144 wxPyEndAllowThreads(__tstate);
38145 if (PyErr_Occurred()) SWIG_fail;
38146 }
38147 {
38148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38149 }
38150 return resultobj;
38151 fail:
38152 return NULL;
38153 }
38154
38155
38156 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38157 PyObject *resultobj = 0;
38158 int arg1 = (int) true ;
38159 int val1 ;
38160 int ecode1 = 0 ;
38161 PyObject * obj0 = 0 ;
38162 char * kwnames[] = {
38163 (char *) "doIt", NULL
38164 };
38165
38166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38167 if (obj0) {
38168 ecode1 = SWIG_AsVal_int(obj0, &val1);
38169 if (!SWIG_IsOK(ecode1)) {
38170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38171 }
38172 arg1 = static_cast< int >(val1);
38173 }
38174 {
38175 PyThreadState* __tstate = wxPyBeginAllowThreads();
38176 wxValidator::SetBellOnError(arg1);
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 resultobj = SWIG_Py_Void();
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38188 PyObject *obj;
38189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38190 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38191 return SWIG_Py_Void();
38192 }
38193
38194 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38195 return SWIG_Python_InitShadowInstance(args);
38196 }
38197
38198 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38199 PyObject *resultobj = 0;
38200 wxPyValidator *result = 0 ;
38201
38202 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38203 {
38204 PyThreadState* __tstate = wxPyBeginAllowThreads();
38205 result = (wxPyValidator *)new wxPyValidator();
38206 wxPyEndAllowThreads(__tstate);
38207 if (PyErr_Occurred()) SWIG_fail;
38208 }
38209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38210 return resultobj;
38211 fail:
38212 return NULL;
38213 }
38214
38215
38216 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38217 PyObject *resultobj = 0;
38218 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38219 PyObject *arg2 = (PyObject *) 0 ;
38220 PyObject *arg3 = (PyObject *) 0 ;
38221 int arg4 = (int) true ;
38222 void *argp1 = 0 ;
38223 int res1 = 0 ;
38224 int val4 ;
38225 int ecode4 = 0 ;
38226 PyObject * obj0 = 0 ;
38227 PyObject * obj1 = 0 ;
38228 PyObject * obj2 = 0 ;
38229 PyObject * obj3 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38238 }
38239 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38240 arg2 = obj1;
38241 arg3 = obj2;
38242 if (obj3) {
38243 ecode4 = SWIG_AsVal_int(obj3, &val4);
38244 if (!SWIG_IsOK(ecode4)) {
38245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38246 }
38247 arg4 = static_cast< int >(val4);
38248 }
38249 {
38250 PyThreadState* __tstate = wxPyBeginAllowThreads();
38251 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38252 wxPyEndAllowThreads(__tstate);
38253 if (PyErr_Occurred()) SWIG_fail;
38254 }
38255 resultobj = SWIG_Py_Void();
38256 return resultobj;
38257 fail:
38258 return NULL;
38259 }
38260
38261
38262 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38263 PyObject *obj;
38264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38265 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38266 return SWIG_Py_Void();
38267 }
38268
38269 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38270 return SWIG_Python_InitShadowInstance(args);
38271 }
38272
38273 SWIGINTERN int DefaultValidator_set(PyObject *) {
38274 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38275 return 1;
38276 }
38277
38278
38279 SWIGINTERN PyObject *DefaultValidator_get(void) {
38280 PyObject *pyobj = 0;
38281
38282 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38283 return pyobj;
38284 }
38285
38286
38287 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38288 PyObject *resultobj = 0;
38289 wxString const &arg1_defvalue = wxPyEmptyString ;
38290 wxString *arg1 = (wxString *) &arg1_defvalue ;
38291 long arg2 = (long) 0 ;
38292 wxMenu *result = 0 ;
38293 bool temp1 = false ;
38294 long val2 ;
38295 int ecode2 = 0 ;
38296 PyObject * obj0 = 0 ;
38297 PyObject * obj1 = 0 ;
38298 char * kwnames[] = {
38299 (char *) "title",(char *) "style", NULL
38300 };
38301
38302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38303 if (obj0) {
38304 {
38305 arg1 = wxString_in_helper(obj0);
38306 if (arg1 == NULL) SWIG_fail;
38307 temp1 = true;
38308 }
38309 }
38310 if (obj1) {
38311 ecode2 = SWIG_AsVal_long(obj1, &val2);
38312 if (!SWIG_IsOK(ecode2)) {
38313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38314 }
38315 arg2 = static_cast< long >(val2);
38316 }
38317 {
38318 if (!wxPyCheckForApp()) SWIG_fail;
38319 PyThreadState* __tstate = wxPyBeginAllowThreads();
38320 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38321 wxPyEndAllowThreads(__tstate);
38322 if (PyErr_Occurred()) SWIG_fail;
38323 }
38324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38325 {
38326 if (temp1)
38327 delete arg1;
38328 }
38329 return resultobj;
38330 fail:
38331 {
38332 if (temp1)
38333 delete arg1;
38334 }
38335 return NULL;
38336 }
38337
38338
38339 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38340 PyObject *resultobj = 0;
38341 wxMenu *arg1 = (wxMenu *) 0 ;
38342 int arg2 ;
38343 wxString *arg3 = 0 ;
38344 wxString const &arg4_defvalue = wxPyEmptyString ;
38345 wxString *arg4 = (wxString *) &arg4_defvalue ;
38346 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38347 wxMenuItem *result = 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 int val2 ;
38351 int ecode2 = 0 ;
38352 bool temp3 = false ;
38353 bool temp4 = false ;
38354 int val5 ;
38355 int ecode5 = 0 ;
38356 PyObject * obj0 = 0 ;
38357 PyObject * obj1 = 0 ;
38358 PyObject * obj2 = 0 ;
38359 PyObject * obj3 = 0 ;
38360 PyObject * obj4 = 0 ;
38361 char * kwnames[] = {
38362 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38363 };
38364
38365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38367 if (!SWIG_IsOK(res1)) {
38368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38369 }
38370 arg1 = reinterpret_cast< wxMenu * >(argp1);
38371 ecode2 = SWIG_AsVal_int(obj1, &val2);
38372 if (!SWIG_IsOK(ecode2)) {
38373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38374 }
38375 arg2 = static_cast< int >(val2);
38376 {
38377 arg3 = wxString_in_helper(obj2);
38378 if (arg3 == NULL) SWIG_fail;
38379 temp3 = true;
38380 }
38381 if (obj3) {
38382 {
38383 arg4 = wxString_in_helper(obj3);
38384 if (arg4 == NULL) SWIG_fail;
38385 temp4 = true;
38386 }
38387 }
38388 if (obj4) {
38389 ecode5 = SWIG_AsVal_int(obj4, &val5);
38390 if (!SWIG_IsOK(ecode5)) {
38391 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38392 }
38393 arg5 = static_cast< wxItemKind >(val5);
38394 }
38395 {
38396 PyThreadState* __tstate = wxPyBeginAllowThreads();
38397 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38398 wxPyEndAllowThreads(__tstate);
38399 if (PyErr_Occurred()) SWIG_fail;
38400 }
38401 {
38402 resultobj = wxPyMake_wxObject(result, (bool)0);
38403 }
38404 {
38405 if (temp3)
38406 delete arg3;
38407 }
38408 {
38409 if (temp4)
38410 delete arg4;
38411 }
38412 return resultobj;
38413 fail:
38414 {
38415 if (temp3)
38416 delete arg3;
38417 }
38418 {
38419 if (temp4)
38420 delete arg4;
38421 }
38422 return NULL;
38423 }
38424
38425
38426 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38427 PyObject *resultobj = 0;
38428 wxMenu *arg1 = (wxMenu *) 0 ;
38429 wxMenuItem *result = 0 ;
38430 void *argp1 = 0 ;
38431 int res1 = 0 ;
38432 PyObject *swig_obj[1] ;
38433
38434 if (!args) SWIG_fail;
38435 swig_obj[0] = args;
38436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38437 if (!SWIG_IsOK(res1)) {
38438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38439 }
38440 arg1 = reinterpret_cast< wxMenu * >(argp1);
38441 {
38442 PyThreadState* __tstate = wxPyBeginAllowThreads();
38443 result = (wxMenuItem *)(arg1)->AppendSeparator();
38444 wxPyEndAllowThreads(__tstate);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 }
38447 {
38448 resultobj = wxPyMake_wxObject(result, (bool)0);
38449 }
38450 return resultobj;
38451 fail:
38452 return NULL;
38453 }
38454
38455
38456 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38457 PyObject *resultobj = 0;
38458 wxMenu *arg1 = (wxMenu *) 0 ;
38459 int arg2 ;
38460 wxString *arg3 = 0 ;
38461 wxString const &arg4_defvalue = wxPyEmptyString ;
38462 wxString *arg4 = (wxString *) &arg4_defvalue ;
38463 wxMenuItem *result = 0 ;
38464 void *argp1 = 0 ;
38465 int res1 = 0 ;
38466 int val2 ;
38467 int ecode2 = 0 ;
38468 bool temp3 = false ;
38469 bool temp4 = false ;
38470 PyObject * obj0 = 0 ;
38471 PyObject * obj1 = 0 ;
38472 PyObject * obj2 = 0 ;
38473 PyObject * obj3 = 0 ;
38474 char * kwnames[] = {
38475 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38476 };
38477
38478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38480 if (!SWIG_IsOK(res1)) {
38481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38482 }
38483 arg1 = reinterpret_cast< wxMenu * >(argp1);
38484 ecode2 = SWIG_AsVal_int(obj1, &val2);
38485 if (!SWIG_IsOK(ecode2)) {
38486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38487 }
38488 arg2 = static_cast< int >(val2);
38489 {
38490 arg3 = wxString_in_helper(obj2);
38491 if (arg3 == NULL) SWIG_fail;
38492 temp3 = true;
38493 }
38494 if (obj3) {
38495 {
38496 arg4 = wxString_in_helper(obj3);
38497 if (arg4 == NULL) SWIG_fail;
38498 temp4 = true;
38499 }
38500 }
38501 {
38502 PyThreadState* __tstate = wxPyBeginAllowThreads();
38503 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38504 wxPyEndAllowThreads(__tstate);
38505 if (PyErr_Occurred()) SWIG_fail;
38506 }
38507 {
38508 resultobj = wxPyMake_wxObject(result, (bool)0);
38509 }
38510 {
38511 if (temp3)
38512 delete arg3;
38513 }
38514 {
38515 if (temp4)
38516 delete arg4;
38517 }
38518 return resultobj;
38519 fail:
38520 {
38521 if (temp3)
38522 delete arg3;
38523 }
38524 {
38525 if (temp4)
38526 delete arg4;
38527 }
38528 return NULL;
38529 }
38530
38531
38532 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38533 PyObject *resultobj = 0;
38534 wxMenu *arg1 = (wxMenu *) 0 ;
38535 int arg2 ;
38536 wxString *arg3 = 0 ;
38537 wxString const &arg4_defvalue = wxPyEmptyString ;
38538 wxString *arg4 = (wxString *) &arg4_defvalue ;
38539 wxMenuItem *result = 0 ;
38540 void *argp1 = 0 ;
38541 int res1 = 0 ;
38542 int val2 ;
38543 int ecode2 = 0 ;
38544 bool temp3 = false ;
38545 bool temp4 = false ;
38546 PyObject * obj0 = 0 ;
38547 PyObject * obj1 = 0 ;
38548 PyObject * obj2 = 0 ;
38549 PyObject * obj3 = 0 ;
38550 char * kwnames[] = {
38551 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38552 };
38553
38554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38556 if (!SWIG_IsOK(res1)) {
38557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38558 }
38559 arg1 = reinterpret_cast< wxMenu * >(argp1);
38560 ecode2 = SWIG_AsVal_int(obj1, &val2);
38561 if (!SWIG_IsOK(ecode2)) {
38562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38563 }
38564 arg2 = static_cast< int >(val2);
38565 {
38566 arg3 = wxString_in_helper(obj2);
38567 if (arg3 == NULL) SWIG_fail;
38568 temp3 = true;
38569 }
38570 if (obj3) {
38571 {
38572 arg4 = wxString_in_helper(obj3);
38573 if (arg4 == NULL) SWIG_fail;
38574 temp4 = true;
38575 }
38576 }
38577 {
38578 PyThreadState* __tstate = wxPyBeginAllowThreads();
38579 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38580 wxPyEndAllowThreads(__tstate);
38581 if (PyErr_Occurred()) SWIG_fail;
38582 }
38583 {
38584 resultobj = wxPyMake_wxObject(result, (bool)0);
38585 }
38586 {
38587 if (temp3)
38588 delete arg3;
38589 }
38590 {
38591 if (temp4)
38592 delete arg4;
38593 }
38594 return resultobj;
38595 fail:
38596 {
38597 if (temp3)
38598 delete arg3;
38599 }
38600 {
38601 if (temp4)
38602 delete arg4;
38603 }
38604 return NULL;
38605 }
38606
38607
38608 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38609 PyObject *resultobj = 0;
38610 wxMenu *arg1 = (wxMenu *) 0 ;
38611 int arg2 ;
38612 wxString *arg3 = 0 ;
38613 wxMenu *arg4 = (wxMenu *) 0 ;
38614 wxString const &arg5_defvalue = wxPyEmptyString ;
38615 wxString *arg5 = (wxString *) &arg5_defvalue ;
38616 wxMenuItem *result = 0 ;
38617 void *argp1 = 0 ;
38618 int res1 = 0 ;
38619 int val2 ;
38620 int ecode2 = 0 ;
38621 bool temp3 = false ;
38622 void *argp4 = 0 ;
38623 int res4 = 0 ;
38624 bool temp5 = false ;
38625 PyObject * obj0 = 0 ;
38626 PyObject * obj1 = 0 ;
38627 PyObject * obj2 = 0 ;
38628 PyObject * obj3 = 0 ;
38629 PyObject * obj4 = 0 ;
38630 char * kwnames[] = {
38631 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38632 };
38633
38634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38636 if (!SWIG_IsOK(res1)) {
38637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38638 }
38639 arg1 = reinterpret_cast< wxMenu * >(argp1);
38640 ecode2 = SWIG_AsVal_int(obj1, &val2);
38641 if (!SWIG_IsOK(ecode2)) {
38642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38643 }
38644 arg2 = static_cast< int >(val2);
38645 {
38646 arg3 = wxString_in_helper(obj2);
38647 if (arg3 == NULL) SWIG_fail;
38648 temp3 = true;
38649 }
38650 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38651 if (!SWIG_IsOK(res4)) {
38652 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38653 }
38654 arg4 = reinterpret_cast< wxMenu * >(argp4);
38655 if (obj4) {
38656 {
38657 arg5 = wxString_in_helper(obj4);
38658 if (arg5 == NULL) SWIG_fail;
38659 temp5 = true;
38660 }
38661 }
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38665 wxPyEndAllowThreads(__tstate);
38666 if (PyErr_Occurred()) SWIG_fail;
38667 }
38668 {
38669 resultobj = wxPyMake_wxObject(result, (bool)0);
38670 }
38671 {
38672 if (temp3)
38673 delete arg3;
38674 }
38675 {
38676 if (temp5)
38677 delete arg5;
38678 }
38679 return resultobj;
38680 fail:
38681 {
38682 if (temp3)
38683 delete arg3;
38684 }
38685 {
38686 if (temp5)
38687 delete arg5;
38688 }
38689 return NULL;
38690 }
38691
38692
38693 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38694 PyObject *resultobj = 0;
38695 wxMenu *arg1 = (wxMenu *) 0 ;
38696 wxMenu *arg2 = (wxMenu *) 0 ;
38697 wxString *arg3 = 0 ;
38698 wxString const &arg4_defvalue = wxPyEmptyString ;
38699 wxString *arg4 = (wxString *) &arg4_defvalue ;
38700 wxMenuItem *result = 0 ;
38701 void *argp1 = 0 ;
38702 int res1 = 0 ;
38703 void *argp2 = 0 ;
38704 int res2 = 0 ;
38705 bool temp3 = false ;
38706 bool temp4 = false ;
38707 PyObject * obj0 = 0 ;
38708 PyObject * obj1 = 0 ;
38709 PyObject * obj2 = 0 ;
38710 PyObject * obj3 = 0 ;
38711 char * kwnames[] = {
38712 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38713 };
38714
38715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38717 if (!SWIG_IsOK(res1)) {
38718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38719 }
38720 arg1 = reinterpret_cast< wxMenu * >(argp1);
38721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38722 if (!SWIG_IsOK(res2)) {
38723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38724 }
38725 arg2 = reinterpret_cast< wxMenu * >(argp2);
38726 {
38727 arg3 = wxString_in_helper(obj2);
38728 if (arg3 == NULL) SWIG_fail;
38729 temp3 = true;
38730 }
38731 if (obj3) {
38732 {
38733 arg4 = wxString_in_helper(obj3);
38734 if (arg4 == NULL) SWIG_fail;
38735 temp4 = true;
38736 }
38737 }
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38741 wxPyEndAllowThreads(__tstate);
38742 if (PyErr_Occurred()) SWIG_fail;
38743 }
38744 {
38745 resultobj = wxPyMake_wxObject(result, (bool)0);
38746 }
38747 {
38748 if (temp3)
38749 delete arg3;
38750 }
38751 {
38752 if (temp4)
38753 delete arg4;
38754 }
38755 return resultobj;
38756 fail:
38757 {
38758 if (temp3)
38759 delete arg3;
38760 }
38761 {
38762 if (temp4)
38763 delete arg4;
38764 }
38765 return NULL;
38766 }
38767
38768
38769 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38770 PyObject *resultobj = 0;
38771 wxMenu *arg1 = (wxMenu *) 0 ;
38772 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38773 wxMenuItem *result = 0 ;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 int res2 = 0 ;
38777 PyObject * obj0 = 0 ;
38778 PyObject * obj1 = 0 ;
38779 char * kwnames[] = {
38780 (char *) "self",(char *) "item", NULL
38781 };
38782
38783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38787 }
38788 arg1 = reinterpret_cast< wxMenu * >(argp1);
38789 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38790 if (!SWIG_IsOK(res2)) {
38791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38792 }
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 result = (wxMenuItem *)(arg1)->Append(arg2);
38796 wxPyEndAllowThreads(__tstate);
38797 if (PyErr_Occurred()) SWIG_fail;
38798 }
38799 {
38800 resultobj = wxPyMake_wxObject(result, (bool)0);
38801 }
38802 return resultobj;
38803 fail:
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj = 0;
38810 wxMenu *arg1 = (wxMenu *) 0 ;
38811 size_t arg2 ;
38812 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38813 wxMenuItem *result = 0 ;
38814 void *argp1 = 0 ;
38815 int res1 = 0 ;
38816 size_t val2 ;
38817 int ecode2 = 0 ;
38818 int res3 = 0 ;
38819 PyObject * obj0 = 0 ;
38820 PyObject * obj1 = 0 ;
38821 PyObject * obj2 = 0 ;
38822 char * kwnames[] = {
38823 (char *) "self",(char *) "pos",(char *) "item", NULL
38824 };
38825
38826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38828 if (!SWIG_IsOK(res1)) {
38829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38830 }
38831 arg1 = reinterpret_cast< wxMenu * >(argp1);
38832 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38833 if (!SWIG_IsOK(ecode2)) {
38834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38835 }
38836 arg2 = static_cast< size_t >(val2);
38837 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38838 if (!SWIG_IsOK(res3)) {
38839 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38840 }
38841 {
38842 PyThreadState* __tstate = wxPyBeginAllowThreads();
38843 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38844 wxPyEndAllowThreads(__tstate);
38845 if (PyErr_Occurred()) SWIG_fail;
38846 }
38847 {
38848 resultobj = wxPyMake_wxObject(result, (bool)0);
38849 }
38850 return resultobj;
38851 fail:
38852 return NULL;
38853 }
38854
38855
38856 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38857 PyObject *resultobj = 0;
38858 wxMenu *arg1 = (wxMenu *) 0 ;
38859 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38860 wxMenuItem *result = 0 ;
38861 void *argp1 = 0 ;
38862 int res1 = 0 ;
38863 int res2 = 0 ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 char * kwnames[] = {
38867 (char *) "self",(char *) "item", NULL
38868 };
38869
38870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38872 if (!SWIG_IsOK(res1)) {
38873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38874 }
38875 arg1 = reinterpret_cast< wxMenu * >(argp1);
38876 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38877 if (!SWIG_IsOK(res2)) {
38878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38879 }
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 {
38887 resultobj = wxPyMake_wxObject(result, (bool)0);
38888 }
38889 return resultobj;
38890 fail:
38891 return NULL;
38892 }
38893
38894
38895 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38896 PyObject *resultobj = 0;
38897 wxMenu *arg1 = (wxMenu *) 0 ;
38898 void *argp1 = 0 ;
38899 int res1 = 0 ;
38900 PyObject *swig_obj[1] ;
38901
38902 if (!args) SWIG_fail;
38903 swig_obj[0] = args;
38904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38905 if (!SWIG_IsOK(res1)) {
38906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38907 }
38908 arg1 = reinterpret_cast< wxMenu * >(argp1);
38909 {
38910 PyThreadState* __tstate = wxPyBeginAllowThreads();
38911 (arg1)->Break();
38912 wxPyEndAllowThreads(__tstate);
38913 if (PyErr_Occurred()) SWIG_fail;
38914 }
38915 resultobj = SWIG_Py_Void();
38916 return resultobj;
38917 fail:
38918 return NULL;
38919 }
38920
38921
38922 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38923 PyObject *resultobj = 0;
38924 wxMenu *arg1 = (wxMenu *) 0 ;
38925 size_t arg2 ;
38926 int arg3 ;
38927 wxString *arg4 = 0 ;
38928 wxString const &arg5_defvalue = wxPyEmptyString ;
38929 wxString *arg5 = (wxString *) &arg5_defvalue ;
38930 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38931 wxMenuItem *result = 0 ;
38932 void *argp1 = 0 ;
38933 int res1 = 0 ;
38934 size_t val2 ;
38935 int ecode2 = 0 ;
38936 int val3 ;
38937 int ecode3 = 0 ;
38938 bool temp4 = false ;
38939 bool temp5 = false ;
38940 int val6 ;
38941 int ecode6 = 0 ;
38942 PyObject * obj0 = 0 ;
38943 PyObject * obj1 = 0 ;
38944 PyObject * obj2 = 0 ;
38945 PyObject * obj3 = 0 ;
38946 PyObject * obj4 = 0 ;
38947 PyObject * obj5 = 0 ;
38948 char * kwnames[] = {
38949 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38950 };
38951
38952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38954 if (!SWIG_IsOK(res1)) {
38955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38956 }
38957 arg1 = reinterpret_cast< wxMenu * >(argp1);
38958 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38959 if (!SWIG_IsOK(ecode2)) {
38960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38961 }
38962 arg2 = static_cast< size_t >(val2);
38963 ecode3 = SWIG_AsVal_int(obj2, &val3);
38964 if (!SWIG_IsOK(ecode3)) {
38965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38966 }
38967 arg3 = static_cast< int >(val3);
38968 {
38969 arg4 = wxString_in_helper(obj3);
38970 if (arg4 == NULL) SWIG_fail;
38971 temp4 = true;
38972 }
38973 if (obj4) {
38974 {
38975 arg5 = wxString_in_helper(obj4);
38976 if (arg5 == NULL) SWIG_fail;
38977 temp5 = true;
38978 }
38979 }
38980 if (obj5) {
38981 ecode6 = SWIG_AsVal_int(obj5, &val6);
38982 if (!SWIG_IsOK(ecode6)) {
38983 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38984 }
38985 arg6 = static_cast< wxItemKind >(val6);
38986 }
38987 {
38988 PyThreadState* __tstate = wxPyBeginAllowThreads();
38989 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38990 wxPyEndAllowThreads(__tstate);
38991 if (PyErr_Occurred()) SWIG_fail;
38992 }
38993 {
38994 resultobj = wxPyMake_wxObject(result, (bool)0);
38995 }
38996 {
38997 if (temp4)
38998 delete arg4;
38999 }
39000 {
39001 if (temp5)
39002 delete arg5;
39003 }
39004 return resultobj;
39005 fail:
39006 {
39007 if (temp4)
39008 delete arg4;
39009 }
39010 {
39011 if (temp5)
39012 delete arg5;
39013 }
39014 return NULL;
39015 }
39016
39017
39018 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39019 PyObject *resultobj = 0;
39020 wxMenu *arg1 = (wxMenu *) 0 ;
39021 size_t arg2 ;
39022 wxMenuItem *result = 0 ;
39023 void *argp1 = 0 ;
39024 int res1 = 0 ;
39025 size_t val2 ;
39026 int ecode2 = 0 ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char * kwnames[] = {
39030 (char *) "self",(char *) "pos", NULL
39031 };
39032
39033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39035 if (!SWIG_IsOK(res1)) {
39036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39037 }
39038 arg1 = reinterpret_cast< wxMenu * >(argp1);
39039 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39040 if (!SWIG_IsOK(ecode2)) {
39041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39042 }
39043 arg2 = static_cast< size_t >(val2);
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 {
39051 resultobj = wxPyMake_wxObject(result, (bool)0);
39052 }
39053 return resultobj;
39054 fail:
39055 return NULL;
39056 }
39057
39058
39059 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj = 0;
39061 wxMenu *arg1 = (wxMenu *) 0 ;
39062 size_t arg2 ;
39063 int arg3 ;
39064 wxString *arg4 = 0 ;
39065 wxString const &arg5_defvalue = wxPyEmptyString ;
39066 wxString *arg5 = (wxString *) &arg5_defvalue ;
39067 wxMenuItem *result = 0 ;
39068 void *argp1 = 0 ;
39069 int res1 = 0 ;
39070 size_t val2 ;
39071 int ecode2 = 0 ;
39072 int val3 ;
39073 int ecode3 = 0 ;
39074 bool temp4 = false ;
39075 bool temp5 = false ;
39076 PyObject * obj0 = 0 ;
39077 PyObject * obj1 = 0 ;
39078 PyObject * obj2 = 0 ;
39079 PyObject * obj3 = 0 ;
39080 PyObject * obj4 = 0 ;
39081 char * kwnames[] = {
39082 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39083 };
39084
39085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39087 if (!SWIG_IsOK(res1)) {
39088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39089 }
39090 arg1 = reinterpret_cast< wxMenu * >(argp1);
39091 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39092 if (!SWIG_IsOK(ecode2)) {
39093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39094 }
39095 arg2 = static_cast< size_t >(val2);
39096 ecode3 = SWIG_AsVal_int(obj2, &val3);
39097 if (!SWIG_IsOK(ecode3)) {
39098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39099 }
39100 arg3 = static_cast< int >(val3);
39101 {
39102 arg4 = wxString_in_helper(obj3);
39103 if (arg4 == NULL) SWIG_fail;
39104 temp4 = true;
39105 }
39106 if (obj4) {
39107 {
39108 arg5 = wxString_in_helper(obj4);
39109 if (arg5 == NULL) SWIG_fail;
39110 temp5 = true;
39111 }
39112 }
39113 {
39114 PyThreadState* __tstate = wxPyBeginAllowThreads();
39115 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39116 wxPyEndAllowThreads(__tstate);
39117 if (PyErr_Occurred()) SWIG_fail;
39118 }
39119 {
39120 resultobj = wxPyMake_wxObject(result, (bool)0);
39121 }
39122 {
39123 if (temp4)
39124 delete arg4;
39125 }
39126 {
39127 if (temp5)
39128 delete arg5;
39129 }
39130 return resultobj;
39131 fail:
39132 {
39133 if (temp4)
39134 delete arg4;
39135 }
39136 {
39137 if (temp5)
39138 delete arg5;
39139 }
39140 return NULL;
39141 }
39142
39143
39144 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39145 PyObject *resultobj = 0;
39146 wxMenu *arg1 = (wxMenu *) 0 ;
39147 size_t arg2 ;
39148 int arg3 ;
39149 wxString *arg4 = 0 ;
39150 wxString const &arg5_defvalue = wxPyEmptyString ;
39151 wxString *arg5 = (wxString *) &arg5_defvalue ;
39152 wxMenuItem *result = 0 ;
39153 void *argp1 = 0 ;
39154 int res1 = 0 ;
39155 size_t val2 ;
39156 int ecode2 = 0 ;
39157 int val3 ;
39158 int ecode3 = 0 ;
39159 bool temp4 = false ;
39160 bool temp5 = false ;
39161 PyObject * obj0 = 0 ;
39162 PyObject * obj1 = 0 ;
39163 PyObject * obj2 = 0 ;
39164 PyObject * obj3 = 0 ;
39165 PyObject * obj4 = 0 ;
39166 char * kwnames[] = {
39167 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39168 };
39169
39170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39172 if (!SWIG_IsOK(res1)) {
39173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39174 }
39175 arg1 = reinterpret_cast< wxMenu * >(argp1);
39176 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39177 if (!SWIG_IsOK(ecode2)) {
39178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39179 }
39180 arg2 = static_cast< size_t >(val2);
39181 ecode3 = SWIG_AsVal_int(obj2, &val3);
39182 if (!SWIG_IsOK(ecode3)) {
39183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39184 }
39185 arg3 = static_cast< int >(val3);
39186 {
39187 arg4 = wxString_in_helper(obj3);
39188 if (arg4 == NULL) SWIG_fail;
39189 temp4 = true;
39190 }
39191 if (obj4) {
39192 {
39193 arg5 = wxString_in_helper(obj4);
39194 if (arg5 == NULL) SWIG_fail;
39195 temp5 = true;
39196 }
39197 }
39198 {
39199 PyThreadState* __tstate = wxPyBeginAllowThreads();
39200 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39201 wxPyEndAllowThreads(__tstate);
39202 if (PyErr_Occurred()) SWIG_fail;
39203 }
39204 {
39205 resultobj = wxPyMake_wxObject(result, (bool)0);
39206 }
39207 {
39208 if (temp4)
39209 delete arg4;
39210 }
39211 {
39212 if (temp5)
39213 delete arg5;
39214 }
39215 return resultobj;
39216 fail:
39217 {
39218 if (temp4)
39219 delete arg4;
39220 }
39221 {
39222 if (temp5)
39223 delete arg5;
39224 }
39225 return NULL;
39226 }
39227
39228
39229 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39230 PyObject *resultobj = 0;
39231 wxMenu *arg1 = (wxMenu *) 0 ;
39232 size_t arg2 ;
39233 int arg3 ;
39234 wxString *arg4 = 0 ;
39235 wxMenu *arg5 = (wxMenu *) 0 ;
39236 wxString const &arg6_defvalue = wxPyEmptyString ;
39237 wxString *arg6 = (wxString *) &arg6_defvalue ;
39238 wxMenuItem *result = 0 ;
39239 void *argp1 = 0 ;
39240 int res1 = 0 ;
39241 size_t val2 ;
39242 int ecode2 = 0 ;
39243 int val3 ;
39244 int ecode3 = 0 ;
39245 bool temp4 = false ;
39246 void *argp5 = 0 ;
39247 int res5 = 0 ;
39248 bool temp6 = false ;
39249 PyObject * obj0 = 0 ;
39250 PyObject * obj1 = 0 ;
39251 PyObject * obj2 = 0 ;
39252 PyObject * obj3 = 0 ;
39253 PyObject * obj4 = 0 ;
39254 PyObject * obj5 = 0 ;
39255 char * kwnames[] = {
39256 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39257 };
39258
39259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39261 if (!SWIG_IsOK(res1)) {
39262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39263 }
39264 arg1 = reinterpret_cast< wxMenu * >(argp1);
39265 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39266 if (!SWIG_IsOK(ecode2)) {
39267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39268 }
39269 arg2 = static_cast< size_t >(val2);
39270 ecode3 = SWIG_AsVal_int(obj2, &val3);
39271 if (!SWIG_IsOK(ecode3)) {
39272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39273 }
39274 arg3 = static_cast< int >(val3);
39275 {
39276 arg4 = wxString_in_helper(obj3);
39277 if (arg4 == NULL) SWIG_fail;
39278 temp4 = true;
39279 }
39280 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39281 if (!SWIG_IsOK(res5)) {
39282 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39283 }
39284 arg5 = reinterpret_cast< wxMenu * >(argp5);
39285 if (obj5) {
39286 {
39287 arg6 = wxString_in_helper(obj5);
39288 if (arg6 == NULL) SWIG_fail;
39289 temp6 = true;
39290 }
39291 }
39292 {
39293 PyThreadState* __tstate = wxPyBeginAllowThreads();
39294 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39295 wxPyEndAllowThreads(__tstate);
39296 if (PyErr_Occurred()) SWIG_fail;
39297 }
39298 {
39299 resultobj = wxPyMake_wxObject(result, (bool)0);
39300 }
39301 {
39302 if (temp4)
39303 delete arg4;
39304 }
39305 {
39306 if (temp6)
39307 delete arg6;
39308 }
39309 return resultobj;
39310 fail:
39311 {
39312 if (temp4)
39313 delete arg4;
39314 }
39315 {
39316 if (temp6)
39317 delete arg6;
39318 }
39319 return NULL;
39320 }
39321
39322
39323 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39324 PyObject *resultobj = 0;
39325 wxMenu *arg1 = (wxMenu *) 0 ;
39326 int arg2 ;
39327 wxString *arg3 = 0 ;
39328 wxString const &arg4_defvalue = wxPyEmptyString ;
39329 wxString *arg4 = (wxString *) &arg4_defvalue ;
39330 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39331 wxMenuItem *result = 0 ;
39332 void *argp1 = 0 ;
39333 int res1 = 0 ;
39334 int val2 ;
39335 int ecode2 = 0 ;
39336 bool temp3 = false ;
39337 bool temp4 = false ;
39338 int val5 ;
39339 int ecode5 = 0 ;
39340 PyObject * obj0 = 0 ;
39341 PyObject * obj1 = 0 ;
39342 PyObject * obj2 = 0 ;
39343 PyObject * obj3 = 0 ;
39344 PyObject * obj4 = 0 ;
39345 char * kwnames[] = {
39346 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39347 };
39348
39349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39351 if (!SWIG_IsOK(res1)) {
39352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39353 }
39354 arg1 = reinterpret_cast< wxMenu * >(argp1);
39355 ecode2 = SWIG_AsVal_int(obj1, &val2);
39356 if (!SWIG_IsOK(ecode2)) {
39357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39358 }
39359 arg2 = static_cast< int >(val2);
39360 {
39361 arg3 = wxString_in_helper(obj2);
39362 if (arg3 == NULL) SWIG_fail;
39363 temp3 = true;
39364 }
39365 if (obj3) {
39366 {
39367 arg4 = wxString_in_helper(obj3);
39368 if (arg4 == NULL) SWIG_fail;
39369 temp4 = true;
39370 }
39371 }
39372 if (obj4) {
39373 ecode5 = SWIG_AsVal_int(obj4, &val5);
39374 if (!SWIG_IsOK(ecode5)) {
39375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39376 }
39377 arg5 = static_cast< wxItemKind >(val5);
39378 }
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 {
39386 resultobj = wxPyMake_wxObject(result, (bool)0);
39387 }
39388 {
39389 if (temp3)
39390 delete arg3;
39391 }
39392 {
39393 if (temp4)
39394 delete arg4;
39395 }
39396 return resultobj;
39397 fail:
39398 {
39399 if (temp3)
39400 delete arg3;
39401 }
39402 {
39403 if (temp4)
39404 delete arg4;
39405 }
39406 return NULL;
39407 }
39408
39409
39410 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39411 PyObject *resultobj = 0;
39412 wxMenu *arg1 = (wxMenu *) 0 ;
39413 wxMenuItem *result = 0 ;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 PyObject *swig_obj[1] ;
39417
39418 if (!args) SWIG_fail;
39419 swig_obj[0] = args;
39420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39421 if (!SWIG_IsOK(res1)) {
39422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39423 }
39424 arg1 = reinterpret_cast< wxMenu * >(argp1);
39425 {
39426 PyThreadState* __tstate = wxPyBeginAllowThreads();
39427 result = (wxMenuItem *)(arg1)->PrependSeparator();
39428 wxPyEndAllowThreads(__tstate);
39429 if (PyErr_Occurred()) SWIG_fail;
39430 }
39431 {
39432 resultobj = wxPyMake_wxObject(result, (bool)0);
39433 }
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj = 0;
39442 wxMenu *arg1 = (wxMenu *) 0 ;
39443 int arg2 ;
39444 wxString *arg3 = 0 ;
39445 wxString const &arg4_defvalue = wxPyEmptyString ;
39446 wxString *arg4 = (wxString *) &arg4_defvalue ;
39447 wxMenuItem *result = 0 ;
39448 void *argp1 = 0 ;
39449 int res1 = 0 ;
39450 int val2 ;
39451 int ecode2 = 0 ;
39452 bool temp3 = false ;
39453 bool temp4 = false ;
39454 PyObject * obj0 = 0 ;
39455 PyObject * obj1 = 0 ;
39456 PyObject * obj2 = 0 ;
39457 PyObject * obj3 = 0 ;
39458 char * kwnames[] = {
39459 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39460 };
39461
39462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39466 }
39467 arg1 = reinterpret_cast< wxMenu * >(argp1);
39468 ecode2 = SWIG_AsVal_int(obj1, &val2);
39469 if (!SWIG_IsOK(ecode2)) {
39470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39471 }
39472 arg2 = static_cast< int >(val2);
39473 {
39474 arg3 = wxString_in_helper(obj2);
39475 if (arg3 == NULL) SWIG_fail;
39476 temp3 = true;
39477 }
39478 if (obj3) {
39479 {
39480 arg4 = wxString_in_helper(obj3);
39481 if (arg4 == NULL) SWIG_fail;
39482 temp4 = true;
39483 }
39484 }
39485 {
39486 PyThreadState* __tstate = wxPyBeginAllowThreads();
39487 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39488 wxPyEndAllowThreads(__tstate);
39489 if (PyErr_Occurred()) SWIG_fail;
39490 }
39491 {
39492 resultobj = wxPyMake_wxObject(result, (bool)0);
39493 }
39494 {
39495 if (temp3)
39496 delete arg3;
39497 }
39498 {
39499 if (temp4)
39500 delete arg4;
39501 }
39502 return resultobj;
39503 fail:
39504 {
39505 if (temp3)
39506 delete arg3;
39507 }
39508 {
39509 if (temp4)
39510 delete arg4;
39511 }
39512 return NULL;
39513 }
39514
39515
39516 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39517 PyObject *resultobj = 0;
39518 wxMenu *arg1 = (wxMenu *) 0 ;
39519 int arg2 ;
39520 wxString *arg3 = 0 ;
39521 wxString const &arg4_defvalue = wxPyEmptyString ;
39522 wxString *arg4 = (wxString *) &arg4_defvalue ;
39523 wxMenuItem *result = 0 ;
39524 void *argp1 = 0 ;
39525 int res1 = 0 ;
39526 int val2 ;
39527 int ecode2 = 0 ;
39528 bool temp3 = false ;
39529 bool temp4 = false ;
39530 PyObject * obj0 = 0 ;
39531 PyObject * obj1 = 0 ;
39532 PyObject * obj2 = 0 ;
39533 PyObject * obj3 = 0 ;
39534 char * kwnames[] = {
39535 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39536 };
39537
39538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39542 }
39543 arg1 = reinterpret_cast< wxMenu * >(argp1);
39544 ecode2 = SWIG_AsVal_int(obj1, &val2);
39545 if (!SWIG_IsOK(ecode2)) {
39546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39547 }
39548 arg2 = static_cast< int >(val2);
39549 {
39550 arg3 = wxString_in_helper(obj2);
39551 if (arg3 == NULL) SWIG_fail;
39552 temp3 = true;
39553 }
39554 if (obj3) {
39555 {
39556 arg4 = wxString_in_helper(obj3);
39557 if (arg4 == NULL) SWIG_fail;
39558 temp4 = true;
39559 }
39560 }
39561 {
39562 PyThreadState* __tstate = wxPyBeginAllowThreads();
39563 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = wxPyMake_wxObject(result, (bool)0);
39569 }
39570 {
39571 if (temp3)
39572 delete arg3;
39573 }
39574 {
39575 if (temp4)
39576 delete arg4;
39577 }
39578 return resultobj;
39579 fail:
39580 {
39581 if (temp3)
39582 delete arg3;
39583 }
39584 {
39585 if (temp4)
39586 delete arg4;
39587 }
39588 return NULL;
39589 }
39590
39591
39592 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39593 PyObject *resultobj = 0;
39594 wxMenu *arg1 = (wxMenu *) 0 ;
39595 int arg2 ;
39596 wxString *arg3 = 0 ;
39597 wxMenu *arg4 = (wxMenu *) 0 ;
39598 wxString const &arg5_defvalue = wxPyEmptyString ;
39599 wxString *arg5 = (wxString *) &arg5_defvalue ;
39600 wxMenuItem *result = 0 ;
39601 void *argp1 = 0 ;
39602 int res1 = 0 ;
39603 int val2 ;
39604 int ecode2 = 0 ;
39605 bool temp3 = false ;
39606 void *argp4 = 0 ;
39607 int res4 = 0 ;
39608 bool temp5 = false ;
39609 PyObject * obj0 = 0 ;
39610 PyObject * obj1 = 0 ;
39611 PyObject * obj2 = 0 ;
39612 PyObject * obj3 = 0 ;
39613 PyObject * obj4 = 0 ;
39614 char * kwnames[] = {
39615 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39616 };
39617
39618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39620 if (!SWIG_IsOK(res1)) {
39621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39622 }
39623 arg1 = reinterpret_cast< wxMenu * >(argp1);
39624 ecode2 = SWIG_AsVal_int(obj1, &val2);
39625 if (!SWIG_IsOK(ecode2)) {
39626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39627 }
39628 arg2 = static_cast< int >(val2);
39629 {
39630 arg3 = wxString_in_helper(obj2);
39631 if (arg3 == NULL) SWIG_fail;
39632 temp3 = true;
39633 }
39634 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39635 if (!SWIG_IsOK(res4)) {
39636 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39637 }
39638 arg4 = reinterpret_cast< wxMenu * >(argp4);
39639 if (obj4) {
39640 {
39641 arg5 = wxString_in_helper(obj4);
39642 if (arg5 == NULL) SWIG_fail;
39643 temp5 = true;
39644 }
39645 }
39646 {
39647 PyThreadState* __tstate = wxPyBeginAllowThreads();
39648 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39649 wxPyEndAllowThreads(__tstate);
39650 if (PyErr_Occurred()) SWIG_fail;
39651 }
39652 {
39653 resultobj = wxPyMake_wxObject(result, (bool)0);
39654 }
39655 {
39656 if (temp3)
39657 delete arg3;
39658 }
39659 {
39660 if (temp5)
39661 delete arg5;
39662 }
39663 return resultobj;
39664 fail:
39665 {
39666 if (temp3)
39667 delete arg3;
39668 }
39669 {
39670 if (temp5)
39671 delete arg5;
39672 }
39673 return NULL;
39674 }
39675
39676
39677 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39678 PyObject *resultobj = 0;
39679 wxMenu *arg1 = (wxMenu *) 0 ;
39680 int arg2 ;
39681 wxMenuItem *result = 0 ;
39682 void *argp1 = 0 ;
39683 int res1 = 0 ;
39684 int val2 ;
39685 int ecode2 = 0 ;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char * kwnames[] = {
39689 (char *) "self",(char *) "id", NULL
39690 };
39691
39692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39694 if (!SWIG_IsOK(res1)) {
39695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39696 }
39697 arg1 = reinterpret_cast< wxMenu * >(argp1);
39698 ecode2 = SWIG_AsVal_int(obj1, &val2);
39699 if (!SWIG_IsOK(ecode2)) {
39700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39701 }
39702 arg2 = static_cast< int >(val2);
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 result = (wxMenuItem *)(arg1)->Remove(arg2);
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 {
39710 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39711 }
39712 return resultobj;
39713 fail:
39714 return NULL;
39715 }
39716
39717
39718 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39719 PyObject *resultobj = 0;
39720 wxMenu *arg1 = (wxMenu *) 0 ;
39721 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39722 wxMenuItem *result = 0 ;
39723 void *argp1 = 0 ;
39724 int res1 = 0 ;
39725 void *argp2 = 0 ;
39726 int res2 = 0 ;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 char * kwnames[] = {
39730 (char *) "self",(char *) "item", NULL
39731 };
39732
39733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39735 if (!SWIG_IsOK(res1)) {
39736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39737 }
39738 arg1 = reinterpret_cast< wxMenu * >(argp1);
39739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39740 if (!SWIG_IsOK(res2)) {
39741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39742 }
39743 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39744 {
39745 PyThreadState* __tstate = wxPyBeginAllowThreads();
39746 result = (wxMenuItem *)(arg1)->Remove(arg2);
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 {
39751 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39752 }
39753 return resultobj;
39754 fail:
39755 return NULL;
39756 }
39757
39758
39759 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39760 PyObject *resultobj = 0;
39761 wxMenu *arg1 = (wxMenu *) 0 ;
39762 int arg2 ;
39763 bool result;
39764 void *argp1 = 0 ;
39765 int res1 = 0 ;
39766 int val2 ;
39767 int ecode2 = 0 ;
39768 PyObject * obj0 = 0 ;
39769 PyObject * obj1 = 0 ;
39770 char * kwnames[] = {
39771 (char *) "self",(char *) "id", NULL
39772 };
39773
39774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39776 if (!SWIG_IsOK(res1)) {
39777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39778 }
39779 arg1 = reinterpret_cast< wxMenu * >(argp1);
39780 ecode2 = SWIG_AsVal_int(obj1, &val2);
39781 if (!SWIG_IsOK(ecode2)) {
39782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39783 }
39784 arg2 = static_cast< int >(val2);
39785 {
39786 PyThreadState* __tstate = wxPyBeginAllowThreads();
39787 result = (bool)(arg1)->Delete(arg2);
39788 wxPyEndAllowThreads(__tstate);
39789 if (PyErr_Occurred()) SWIG_fail;
39790 }
39791 {
39792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39793 }
39794 return resultobj;
39795 fail:
39796 return NULL;
39797 }
39798
39799
39800 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39801 PyObject *resultobj = 0;
39802 wxMenu *arg1 = (wxMenu *) 0 ;
39803 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39804 bool result;
39805 void *argp1 = 0 ;
39806 int res1 = 0 ;
39807 void *argp2 = 0 ;
39808 int res2 = 0 ;
39809 PyObject * obj0 = 0 ;
39810 PyObject * obj1 = 0 ;
39811 char * kwnames[] = {
39812 (char *) "self",(char *) "item", NULL
39813 };
39814
39815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39817 if (!SWIG_IsOK(res1)) {
39818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39819 }
39820 arg1 = reinterpret_cast< wxMenu * >(argp1);
39821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39822 if (!SWIG_IsOK(res2)) {
39823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39824 }
39825 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39826 {
39827 PyThreadState* __tstate = wxPyBeginAllowThreads();
39828 result = (bool)(arg1)->Delete(arg2);
39829 wxPyEndAllowThreads(__tstate);
39830 if (PyErr_Occurred()) SWIG_fail;
39831 }
39832 {
39833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39834 }
39835 return resultobj;
39836 fail:
39837 return NULL;
39838 }
39839
39840
39841 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39842 PyObject *resultobj = 0;
39843 wxMenu *arg1 = (wxMenu *) 0 ;
39844 void *argp1 = 0 ;
39845 int res1 = 0 ;
39846 PyObject *swig_obj[1] ;
39847
39848 if (!args) SWIG_fail;
39849 swig_obj[0] = args;
39850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39851 if (!SWIG_IsOK(res1)) {
39852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39853 }
39854 arg1 = reinterpret_cast< wxMenu * >(argp1);
39855 {
39856 PyThreadState* __tstate = wxPyBeginAllowThreads();
39857 wxMenu_Destroy(arg1);
39858 wxPyEndAllowThreads(__tstate);
39859 if (PyErr_Occurred()) SWIG_fail;
39860 }
39861 resultobj = SWIG_Py_Void();
39862 return resultobj;
39863 fail:
39864 return NULL;
39865 }
39866
39867
39868 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39869 PyObject *resultobj = 0;
39870 wxMenu *arg1 = (wxMenu *) 0 ;
39871 int arg2 ;
39872 bool result;
39873 void *argp1 = 0 ;
39874 int res1 = 0 ;
39875 int val2 ;
39876 int ecode2 = 0 ;
39877 PyObject * obj0 = 0 ;
39878 PyObject * obj1 = 0 ;
39879 char * kwnames[] = {
39880 (char *) "self",(char *) "id", NULL
39881 };
39882
39883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39885 if (!SWIG_IsOK(res1)) {
39886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39887 }
39888 arg1 = reinterpret_cast< wxMenu * >(argp1);
39889 ecode2 = SWIG_AsVal_int(obj1, &val2);
39890 if (!SWIG_IsOK(ecode2)) {
39891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39892 }
39893 arg2 = static_cast< int >(val2);
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 result = (bool)(arg1)->Destroy(arg2);
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39902 }
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39910 PyObject *resultobj = 0;
39911 wxMenu *arg1 = (wxMenu *) 0 ;
39912 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39913 bool result;
39914 void *argp1 = 0 ;
39915 int res1 = 0 ;
39916 void *argp2 = 0 ;
39917 int res2 = 0 ;
39918 PyObject * obj0 = 0 ;
39919 PyObject * obj1 = 0 ;
39920 char * kwnames[] = {
39921 (char *) "self",(char *) "item", NULL
39922 };
39923
39924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39926 if (!SWIG_IsOK(res1)) {
39927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39928 }
39929 arg1 = reinterpret_cast< wxMenu * >(argp1);
39930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39931 if (!SWIG_IsOK(res2)) {
39932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39933 }
39934 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 result = (bool)(arg1)->Destroy(arg2);
39938 wxPyEndAllowThreads(__tstate);
39939 if (PyErr_Occurred()) SWIG_fail;
39940 }
39941 {
39942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39943 }
39944 return resultobj;
39945 fail:
39946 return NULL;
39947 }
39948
39949
39950 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39951 PyObject *resultobj = 0;
39952 wxMenu *arg1 = (wxMenu *) 0 ;
39953 size_t result;
39954 void *argp1 = 0 ;
39955 int res1 = 0 ;
39956 PyObject *swig_obj[1] ;
39957
39958 if (!args) SWIG_fail;
39959 swig_obj[0] = args;
39960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39961 if (!SWIG_IsOK(res1)) {
39962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39963 }
39964 arg1 = reinterpret_cast< wxMenu * >(argp1);
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39972 return resultobj;
39973 fail:
39974 return NULL;
39975 }
39976
39977
39978 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39979 PyObject *resultobj = 0;
39980 wxMenu *arg1 = (wxMenu *) 0 ;
39981 PyObject *result = 0 ;
39982 void *argp1 = 0 ;
39983 int res1 = 0 ;
39984 PyObject *swig_obj[1] ;
39985
39986 if (!args) SWIG_fail;
39987 swig_obj[0] = args;
39988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39989 if (!SWIG_IsOK(res1)) {
39990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39991 }
39992 arg1 = reinterpret_cast< wxMenu * >(argp1);
39993 {
39994 PyThreadState* __tstate = wxPyBeginAllowThreads();
39995 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39996 wxPyEndAllowThreads(__tstate);
39997 if (PyErr_Occurred()) SWIG_fail;
39998 }
39999 resultobj = result;
40000 return resultobj;
40001 fail:
40002 return NULL;
40003 }
40004
40005
40006 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40007 PyObject *resultobj = 0;
40008 wxMenu *arg1 = (wxMenu *) 0 ;
40009 wxString *arg2 = 0 ;
40010 int result;
40011 void *argp1 = 0 ;
40012 int res1 = 0 ;
40013 bool temp2 = false ;
40014 PyObject * obj0 = 0 ;
40015 PyObject * obj1 = 0 ;
40016 char * kwnames[] = {
40017 (char *) "self",(char *) "item", NULL
40018 };
40019
40020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40022 if (!SWIG_IsOK(res1)) {
40023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40024 }
40025 arg1 = reinterpret_cast< wxMenu * >(argp1);
40026 {
40027 arg2 = wxString_in_helper(obj1);
40028 if (arg2 == NULL) SWIG_fail;
40029 temp2 = true;
40030 }
40031 {
40032 PyThreadState* __tstate = wxPyBeginAllowThreads();
40033 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40034 wxPyEndAllowThreads(__tstate);
40035 if (PyErr_Occurred()) SWIG_fail;
40036 }
40037 resultobj = SWIG_From_int(static_cast< int >(result));
40038 {
40039 if (temp2)
40040 delete arg2;
40041 }
40042 return resultobj;
40043 fail:
40044 {
40045 if (temp2)
40046 delete arg2;
40047 }
40048 return NULL;
40049 }
40050
40051
40052 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40053 PyObject *resultobj = 0;
40054 wxMenu *arg1 = (wxMenu *) 0 ;
40055 int arg2 ;
40056 wxMenuItem *result = 0 ;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 int val2 ;
40060 int ecode2 = 0 ;
40061 PyObject * obj0 = 0 ;
40062 PyObject * obj1 = 0 ;
40063 char * kwnames[] = {
40064 (char *) "self",(char *) "id", NULL
40065 };
40066
40067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40069 if (!SWIG_IsOK(res1)) {
40070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40071 }
40072 arg1 = reinterpret_cast< wxMenu * >(argp1);
40073 ecode2 = SWIG_AsVal_int(obj1, &val2);
40074 if (!SWIG_IsOK(ecode2)) {
40075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40076 }
40077 arg2 = static_cast< int >(val2);
40078 {
40079 PyThreadState* __tstate = wxPyBeginAllowThreads();
40080 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40081 wxPyEndAllowThreads(__tstate);
40082 if (PyErr_Occurred()) SWIG_fail;
40083 }
40084 {
40085 resultobj = wxPyMake_wxObject(result, (bool)0);
40086 }
40087 return resultobj;
40088 fail:
40089 return NULL;
40090 }
40091
40092
40093 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40094 PyObject *resultobj = 0;
40095 wxMenu *arg1 = (wxMenu *) 0 ;
40096 size_t arg2 ;
40097 wxMenuItem *result = 0 ;
40098 void *argp1 = 0 ;
40099 int res1 = 0 ;
40100 size_t val2 ;
40101 int ecode2 = 0 ;
40102 PyObject * obj0 = 0 ;
40103 PyObject * obj1 = 0 ;
40104 char * kwnames[] = {
40105 (char *) "self",(char *) "position", NULL
40106 };
40107
40108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40110 if (!SWIG_IsOK(res1)) {
40111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40112 }
40113 arg1 = reinterpret_cast< wxMenu * >(argp1);
40114 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40115 if (!SWIG_IsOK(ecode2)) {
40116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40117 }
40118 arg2 = static_cast< size_t >(val2);
40119 {
40120 PyThreadState* __tstate = wxPyBeginAllowThreads();
40121 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40122 wxPyEndAllowThreads(__tstate);
40123 if (PyErr_Occurred()) SWIG_fail;
40124 }
40125 {
40126 resultobj = wxPyMake_wxObject(result, (bool)0);
40127 }
40128 return resultobj;
40129 fail:
40130 return NULL;
40131 }
40132
40133
40134 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40135 PyObject *resultobj = 0;
40136 wxMenu *arg1 = (wxMenu *) 0 ;
40137 int arg2 ;
40138 bool arg3 ;
40139 void *argp1 = 0 ;
40140 int res1 = 0 ;
40141 int val2 ;
40142 int ecode2 = 0 ;
40143 bool val3 ;
40144 int ecode3 = 0 ;
40145 PyObject * obj0 = 0 ;
40146 PyObject * obj1 = 0 ;
40147 PyObject * obj2 = 0 ;
40148 char * kwnames[] = {
40149 (char *) "self",(char *) "id",(char *) "enable", NULL
40150 };
40151
40152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40154 if (!SWIG_IsOK(res1)) {
40155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40156 }
40157 arg1 = reinterpret_cast< wxMenu * >(argp1);
40158 ecode2 = SWIG_AsVal_int(obj1, &val2);
40159 if (!SWIG_IsOK(ecode2)) {
40160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40161 }
40162 arg2 = static_cast< int >(val2);
40163 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40164 if (!SWIG_IsOK(ecode3)) {
40165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40166 }
40167 arg3 = static_cast< bool >(val3);
40168 {
40169 PyThreadState* __tstate = wxPyBeginAllowThreads();
40170 (arg1)->Enable(arg2,arg3);
40171 wxPyEndAllowThreads(__tstate);
40172 if (PyErr_Occurred()) SWIG_fail;
40173 }
40174 resultobj = SWIG_Py_Void();
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40182 PyObject *resultobj = 0;
40183 wxMenu *arg1 = (wxMenu *) 0 ;
40184 int arg2 ;
40185 bool result;
40186 void *argp1 = 0 ;
40187 int res1 = 0 ;
40188 int val2 ;
40189 int ecode2 = 0 ;
40190 PyObject * obj0 = 0 ;
40191 PyObject * obj1 = 0 ;
40192 char * kwnames[] = {
40193 (char *) "self",(char *) "id", NULL
40194 };
40195
40196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40198 if (!SWIG_IsOK(res1)) {
40199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40200 }
40201 arg1 = reinterpret_cast< wxMenu * >(argp1);
40202 ecode2 = SWIG_AsVal_int(obj1, &val2);
40203 if (!SWIG_IsOK(ecode2)) {
40204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40205 }
40206 arg2 = static_cast< int >(val2);
40207 {
40208 PyThreadState* __tstate = wxPyBeginAllowThreads();
40209 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 {
40214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40215 }
40216 return resultobj;
40217 fail:
40218 return NULL;
40219 }
40220
40221
40222 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40223 PyObject *resultobj = 0;
40224 wxMenu *arg1 = (wxMenu *) 0 ;
40225 int arg2 ;
40226 bool arg3 ;
40227 void *argp1 = 0 ;
40228 int res1 = 0 ;
40229 int val2 ;
40230 int ecode2 = 0 ;
40231 bool val3 ;
40232 int ecode3 = 0 ;
40233 PyObject * obj0 = 0 ;
40234 PyObject * obj1 = 0 ;
40235 PyObject * obj2 = 0 ;
40236 char * kwnames[] = {
40237 (char *) "self",(char *) "id",(char *) "check", NULL
40238 };
40239
40240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40242 if (!SWIG_IsOK(res1)) {
40243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40244 }
40245 arg1 = reinterpret_cast< wxMenu * >(argp1);
40246 ecode2 = SWIG_AsVal_int(obj1, &val2);
40247 if (!SWIG_IsOK(ecode2)) {
40248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40249 }
40250 arg2 = static_cast< int >(val2);
40251 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40252 if (!SWIG_IsOK(ecode3)) {
40253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40254 }
40255 arg3 = static_cast< bool >(val3);
40256 {
40257 PyThreadState* __tstate = wxPyBeginAllowThreads();
40258 (arg1)->Check(arg2,arg3);
40259 wxPyEndAllowThreads(__tstate);
40260 if (PyErr_Occurred()) SWIG_fail;
40261 }
40262 resultobj = SWIG_Py_Void();
40263 return resultobj;
40264 fail:
40265 return NULL;
40266 }
40267
40268
40269 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40270 PyObject *resultobj = 0;
40271 wxMenu *arg1 = (wxMenu *) 0 ;
40272 int arg2 ;
40273 bool result;
40274 void *argp1 = 0 ;
40275 int res1 = 0 ;
40276 int val2 ;
40277 int ecode2 = 0 ;
40278 PyObject * obj0 = 0 ;
40279 PyObject * obj1 = 0 ;
40280 char * kwnames[] = {
40281 (char *) "self",(char *) "id", NULL
40282 };
40283
40284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40286 if (!SWIG_IsOK(res1)) {
40287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40288 }
40289 arg1 = reinterpret_cast< wxMenu * >(argp1);
40290 ecode2 = SWIG_AsVal_int(obj1, &val2);
40291 if (!SWIG_IsOK(ecode2)) {
40292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40293 }
40294 arg2 = static_cast< int >(val2);
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40298 wxPyEndAllowThreads(__tstate);
40299 if (PyErr_Occurred()) SWIG_fail;
40300 }
40301 {
40302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40303 }
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = 0;
40312 wxMenu *arg1 = (wxMenu *) 0 ;
40313 int arg2 ;
40314 wxString *arg3 = 0 ;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 int val2 ;
40318 int ecode2 = 0 ;
40319 bool temp3 = false ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 PyObject * obj2 = 0 ;
40323 char * kwnames[] = {
40324 (char *) "self",(char *) "id",(char *) "label", NULL
40325 };
40326
40327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40329 if (!SWIG_IsOK(res1)) {
40330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40331 }
40332 arg1 = reinterpret_cast< wxMenu * >(argp1);
40333 ecode2 = SWIG_AsVal_int(obj1, &val2);
40334 if (!SWIG_IsOK(ecode2)) {
40335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40336 }
40337 arg2 = static_cast< int >(val2);
40338 {
40339 arg3 = wxString_in_helper(obj2);
40340 if (arg3 == NULL) SWIG_fail;
40341 temp3 = true;
40342 }
40343 {
40344 PyThreadState* __tstate = wxPyBeginAllowThreads();
40345 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 resultobj = SWIG_Py_Void();
40350 {
40351 if (temp3)
40352 delete arg3;
40353 }
40354 return resultobj;
40355 fail:
40356 {
40357 if (temp3)
40358 delete arg3;
40359 }
40360 return NULL;
40361 }
40362
40363
40364 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40365 PyObject *resultobj = 0;
40366 wxMenu *arg1 = (wxMenu *) 0 ;
40367 int arg2 ;
40368 wxString result;
40369 void *argp1 = 0 ;
40370 int res1 = 0 ;
40371 int val2 ;
40372 int ecode2 = 0 ;
40373 PyObject * obj0 = 0 ;
40374 PyObject * obj1 = 0 ;
40375 char * kwnames[] = {
40376 (char *) "self",(char *) "id", NULL
40377 };
40378
40379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 ecode2 = SWIG_AsVal_int(obj1, &val2);
40386 if (!SWIG_IsOK(ecode2)) {
40387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40388 }
40389 arg2 = static_cast< int >(val2);
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 {
40397 #if wxUSE_UNICODE
40398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40399 #else
40400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40401 #endif
40402 }
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj = 0;
40411 wxMenu *arg1 = (wxMenu *) 0 ;
40412 int arg2 ;
40413 wxString *arg3 = 0 ;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 int val2 ;
40417 int ecode2 = 0 ;
40418 bool temp3 = false ;
40419 PyObject * obj0 = 0 ;
40420 PyObject * obj1 = 0 ;
40421 PyObject * obj2 = 0 ;
40422 char * kwnames[] = {
40423 (char *) "self",(char *) "id",(char *) "helpString", NULL
40424 };
40425
40426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40428 if (!SWIG_IsOK(res1)) {
40429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40430 }
40431 arg1 = reinterpret_cast< wxMenu * >(argp1);
40432 ecode2 = SWIG_AsVal_int(obj1, &val2);
40433 if (!SWIG_IsOK(ecode2)) {
40434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40435 }
40436 arg2 = static_cast< int >(val2);
40437 {
40438 arg3 = wxString_in_helper(obj2);
40439 if (arg3 == NULL) SWIG_fail;
40440 temp3 = true;
40441 }
40442 {
40443 PyThreadState* __tstate = wxPyBeginAllowThreads();
40444 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40445 wxPyEndAllowThreads(__tstate);
40446 if (PyErr_Occurred()) SWIG_fail;
40447 }
40448 resultobj = SWIG_Py_Void();
40449 {
40450 if (temp3)
40451 delete arg3;
40452 }
40453 return resultobj;
40454 fail:
40455 {
40456 if (temp3)
40457 delete arg3;
40458 }
40459 return NULL;
40460 }
40461
40462
40463 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40464 PyObject *resultobj = 0;
40465 wxMenu *arg1 = (wxMenu *) 0 ;
40466 int arg2 ;
40467 wxString result;
40468 void *argp1 = 0 ;
40469 int res1 = 0 ;
40470 int val2 ;
40471 int ecode2 = 0 ;
40472 PyObject * obj0 = 0 ;
40473 PyObject * obj1 = 0 ;
40474 char * kwnames[] = {
40475 (char *) "self",(char *) "id", NULL
40476 };
40477
40478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40480 if (!SWIG_IsOK(res1)) {
40481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40482 }
40483 arg1 = reinterpret_cast< wxMenu * >(argp1);
40484 ecode2 = SWIG_AsVal_int(obj1, &val2);
40485 if (!SWIG_IsOK(ecode2)) {
40486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40487 }
40488 arg2 = static_cast< int >(val2);
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 {
40496 #if wxUSE_UNICODE
40497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40498 #else
40499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40500 #endif
40501 }
40502 return resultobj;
40503 fail:
40504 return NULL;
40505 }
40506
40507
40508 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40509 PyObject *resultobj = 0;
40510 wxMenu *arg1 = (wxMenu *) 0 ;
40511 wxString *arg2 = 0 ;
40512 void *argp1 = 0 ;
40513 int res1 = 0 ;
40514 bool temp2 = false ;
40515 PyObject * obj0 = 0 ;
40516 PyObject * obj1 = 0 ;
40517 char * kwnames[] = {
40518 (char *) "self",(char *) "title", NULL
40519 };
40520
40521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40523 if (!SWIG_IsOK(res1)) {
40524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40525 }
40526 arg1 = reinterpret_cast< wxMenu * >(argp1);
40527 {
40528 arg2 = wxString_in_helper(obj1);
40529 if (arg2 == NULL) SWIG_fail;
40530 temp2 = true;
40531 }
40532 {
40533 PyThreadState* __tstate = wxPyBeginAllowThreads();
40534 (arg1)->SetTitle((wxString const &)*arg2);
40535 wxPyEndAllowThreads(__tstate);
40536 if (PyErr_Occurred()) SWIG_fail;
40537 }
40538 resultobj = SWIG_Py_Void();
40539 {
40540 if (temp2)
40541 delete arg2;
40542 }
40543 return resultobj;
40544 fail:
40545 {
40546 if (temp2)
40547 delete arg2;
40548 }
40549 return NULL;
40550 }
40551
40552
40553 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40554 PyObject *resultobj = 0;
40555 wxMenu *arg1 = (wxMenu *) 0 ;
40556 wxString result;
40557 void *argp1 = 0 ;
40558 int res1 = 0 ;
40559 PyObject *swig_obj[1] ;
40560
40561 if (!args) SWIG_fail;
40562 swig_obj[0] = args;
40563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40564 if (!SWIG_IsOK(res1)) {
40565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40566 }
40567 arg1 = reinterpret_cast< wxMenu * >(argp1);
40568 {
40569 PyThreadState* __tstate = wxPyBeginAllowThreads();
40570 result = ((wxMenu const *)arg1)->GetTitle();
40571 wxPyEndAllowThreads(__tstate);
40572 if (PyErr_Occurred()) SWIG_fail;
40573 }
40574 {
40575 #if wxUSE_UNICODE
40576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40577 #else
40578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40579 #endif
40580 }
40581 return resultobj;
40582 fail:
40583 return NULL;
40584 }
40585
40586
40587 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40588 PyObject *resultobj = 0;
40589 wxMenu *arg1 = (wxMenu *) 0 ;
40590 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40591 void *argp1 = 0 ;
40592 int res1 = 0 ;
40593 void *argp2 = 0 ;
40594 int res2 = 0 ;
40595 PyObject * obj0 = 0 ;
40596 PyObject * obj1 = 0 ;
40597 char * kwnames[] = {
40598 (char *) "self",(char *) "handler", NULL
40599 };
40600
40601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40603 if (!SWIG_IsOK(res1)) {
40604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40605 }
40606 arg1 = reinterpret_cast< wxMenu * >(argp1);
40607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40608 if (!SWIG_IsOK(res2)) {
40609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40610 }
40611 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 (arg1)->SetEventHandler(arg2);
40615 wxPyEndAllowThreads(__tstate);
40616 if (PyErr_Occurred()) SWIG_fail;
40617 }
40618 resultobj = SWIG_Py_Void();
40619 return resultobj;
40620 fail:
40621 return NULL;
40622 }
40623
40624
40625 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40626 PyObject *resultobj = 0;
40627 wxMenu *arg1 = (wxMenu *) 0 ;
40628 wxEvtHandler *result = 0 ;
40629 void *argp1 = 0 ;
40630 int res1 = 0 ;
40631 PyObject *swig_obj[1] ;
40632
40633 if (!args) SWIG_fail;
40634 swig_obj[0] = args;
40635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40636 if (!SWIG_IsOK(res1)) {
40637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40638 }
40639 arg1 = reinterpret_cast< wxMenu * >(argp1);
40640 {
40641 PyThreadState* __tstate = wxPyBeginAllowThreads();
40642 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40643 wxPyEndAllowThreads(__tstate);
40644 if (PyErr_Occurred()) SWIG_fail;
40645 }
40646 {
40647 resultobj = wxPyMake_wxObject(result, 0);
40648 }
40649 return resultobj;
40650 fail:
40651 return NULL;
40652 }
40653
40654
40655 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40656 PyObject *resultobj = 0;
40657 wxMenu *arg1 = (wxMenu *) 0 ;
40658 wxWindow *arg2 = (wxWindow *) 0 ;
40659 void *argp1 = 0 ;
40660 int res1 = 0 ;
40661 void *argp2 = 0 ;
40662 int res2 = 0 ;
40663 PyObject * obj0 = 0 ;
40664 PyObject * obj1 = 0 ;
40665 char * kwnames[] = {
40666 (char *) "self",(char *) "win", NULL
40667 };
40668
40669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40671 if (!SWIG_IsOK(res1)) {
40672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40673 }
40674 arg1 = reinterpret_cast< wxMenu * >(argp1);
40675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40676 if (!SWIG_IsOK(res2)) {
40677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40678 }
40679 arg2 = reinterpret_cast< wxWindow * >(argp2);
40680 {
40681 PyThreadState* __tstate = wxPyBeginAllowThreads();
40682 (arg1)->SetInvokingWindow(arg2);
40683 wxPyEndAllowThreads(__tstate);
40684 if (PyErr_Occurred()) SWIG_fail;
40685 }
40686 resultobj = SWIG_Py_Void();
40687 return resultobj;
40688 fail:
40689 return NULL;
40690 }
40691
40692
40693 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40694 PyObject *resultobj = 0;
40695 wxMenu *arg1 = (wxMenu *) 0 ;
40696 wxWindow *result = 0 ;
40697 void *argp1 = 0 ;
40698 int res1 = 0 ;
40699 PyObject *swig_obj[1] ;
40700
40701 if (!args) SWIG_fail;
40702 swig_obj[0] = args;
40703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40704 if (!SWIG_IsOK(res1)) {
40705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40706 }
40707 arg1 = reinterpret_cast< wxMenu * >(argp1);
40708 {
40709 PyThreadState* __tstate = wxPyBeginAllowThreads();
40710 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40711 wxPyEndAllowThreads(__tstate);
40712 if (PyErr_Occurred()) SWIG_fail;
40713 }
40714 {
40715 resultobj = wxPyMake_wxObject(result, 0);
40716 }
40717 return resultobj;
40718 fail:
40719 return NULL;
40720 }
40721
40722
40723 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40724 PyObject *resultobj = 0;
40725 wxMenu *arg1 = (wxMenu *) 0 ;
40726 long result;
40727 void *argp1 = 0 ;
40728 int res1 = 0 ;
40729 PyObject *swig_obj[1] ;
40730
40731 if (!args) SWIG_fail;
40732 swig_obj[0] = args;
40733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40734 if (!SWIG_IsOK(res1)) {
40735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40736 }
40737 arg1 = reinterpret_cast< wxMenu * >(argp1);
40738 {
40739 PyThreadState* __tstate = wxPyBeginAllowThreads();
40740 result = (long)((wxMenu const *)arg1)->GetStyle();
40741 wxPyEndAllowThreads(__tstate);
40742 if (PyErr_Occurred()) SWIG_fail;
40743 }
40744 resultobj = SWIG_From_long(static_cast< long >(result));
40745 return resultobj;
40746 fail:
40747 return NULL;
40748 }
40749
40750
40751 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40752 PyObject *resultobj = 0;
40753 wxMenu *arg1 = (wxMenu *) 0 ;
40754 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40755 void *argp1 = 0 ;
40756 int res1 = 0 ;
40757 void *argp2 = 0 ;
40758 int res2 = 0 ;
40759 PyObject * obj0 = 0 ;
40760 PyObject * obj1 = 0 ;
40761 char * kwnames[] = {
40762 (char *) "self",(char *) "source", NULL
40763 };
40764
40765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40767 if (!SWIG_IsOK(res1)) {
40768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40769 }
40770 arg1 = reinterpret_cast< wxMenu * >(argp1);
40771 if (obj1) {
40772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40773 if (!SWIG_IsOK(res2)) {
40774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40775 }
40776 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40777 }
40778 {
40779 PyThreadState* __tstate = wxPyBeginAllowThreads();
40780 (arg1)->UpdateUI(arg2);
40781 wxPyEndAllowThreads(__tstate);
40782 if (PyErr_Occurred()) SWIG_fail;
40783 }
40784 resultobj = SWIG_Py_Void();
40785 return resultobj;
40786 fail:
40787 return NULL;
40788 }
40789
40790
40791 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40792 PyObject *resultobj = 0;
40793 wxMenu *arg1 = (wxMenu *) 0 ;
40794 wxMenuBar *result = 0 ;
40795 void *argp1 = 0 ;
40796 int res1 = 0 ;
40797 PyObject *swig_obj[1] ;
40798
40799 if (!args) SWIG_fail;
40800 swig_obj[0] = args;
40801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40802 if (!SWIG_IsOK(res1)) {
40803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40804 }
40805 arg1 = reinterpret_cast< wxMenu * >(argp1);
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 {
40813 resultobj = wxPyMake_wxObject(result, (bool)0);
40814 }
40815 return resultobj;
40816 fail:
40817 return NULL;
40818 }
40819
40820
40821 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj = 0;
40823 wxMenu *arg1 = (wxMenu *) 0 ;
40824 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40825 void *argp1 = 0 ;
40826 int res1 = 0 ;
40827 void *argp2 = 0 ;
40828 int res2 = 0 ;
40829 PyObject * obj0 = 0 ;
40830 PyObject * obj1 = 0 ;
40831 char * kwnames[] = {
40832 (char *) "self",(char *) "menubar", NULL
40833 };
40834
40835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40837 if (!SWIG_IsOK(res1)) {
40838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40839 }
40840 arg1 = reinterpret_cast< wxMenu * >(argp1);
40841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40842 if (!SWIG_IsOK(res2)) {
40843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40844 }
40845 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 (arg1)->Attach(arg2);
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 resultobj = SWIG_Py_Void();
40853 return resultobj;
40854 fail:
40855 return NULL;
40856 }
40857
40858
40859 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40860 PyObject *resultobj = 0;
40861 wxMenu *arg1 = (wxMenu *) 0 ;
40862 void *argp1 = 0 ;
40863 int res1 = 0 ;
40864 PyObject *swig_obj[1] ;
40865
40866 if (!args) SWIG_fail;
40867 swig_obj[0] = args;
40868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40869 if (!SWIG_IsOK(res1)) {
40870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40871 }
40872 arg1 = reinterpret_cast< wxMenu * >(argp1);
40873 {
40874 PyThreadState* __tstate = wxPyBeginAllowThreads();
40875 (arg1)->Detach();
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 resultobj = SWIG_Py_Void();
40880 return resultobj;
40881 fail:
40882 return NULL;
40883 }
40884
40885
40886 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40887 PyObject *resultobj = 0;
40888 wxMenu *arg1 = (wxMenu *) 0 ;
40889 bool result;
40890 void *argp1 = 0 ;
40891 int res1 = 0 ;
40892 PyObject *swig_obj[1] ;
40893
40894 if (!args) SWIG_fail;
40895 swig_obj[0] = args;
40896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40897 if (!SWIG_IsOK(res1)) {
40898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40899 }
40900 arg1 = reinterpret_cast< wxMenu * >(argp1);
40901 {
40902 PyThreadState* __tstate = wxPyBeginAllowThreads();
40903 result = (bool)((wxMenu const *)arg1)->IsAttached();
40904 wxPyEndAllowThreads(__tstate);
40905 if (PyErr_Occurred()) SWIG_fail;
40906 }
40907 {
40908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40909 }
40910 return resultobj;
40911 fail:
40912 return NULL;
40913 }
40914
40915
40916 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40917 PyObject *resultobj = 0;
40918 wxMenu *arg1 = (wxMenu *) 0 ;
40919 wxMenu *arg2 = (wxMenu *) 0 ;
40920 void *argp1 = 0 ;
40921 int res1 = 0 ;
40922 void *argp2 = 0 ;
40923 int res2 = 0 ;
40924 PyObject * obj0 = 0 ;
40925 PyObject * obj1 = 0 ;
40926 char * kwnames[] = {
40927 (char *) "self",(char *) "parent", NULL
40928 };
40929
40930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40932 if (!SWIG_IsOK(res1)) {
40933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40934 }
40935 arg1 = reinterpret_cast< wxMenu * >(argp1);
40936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40937 if (!SWIG_IsOK(res2)) {
40938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40939 }
40940 arg2 = reinterpret_cast< wxMenu * >(argp2);
40941 {
40942 PyThreadState* __tstate = wxPyBeginAllowThreads();
40943 (arg1)->SetParent(arg2);
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 resultobj = SWIG_Py_Void();
40948 return resultobj;
40949 fail:
40950 return NULL;
40951 }
40952
40953
40954 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40955 PyObject *resultobj = 0;
40956 wxMenu *arg1 = (wxMenu *) 0 ;
40957 wxMenu *result = 0 ;
40958 void *argp1 = 0 ;
40959 int res1 = 0 ;
40960 PyObject *swig_obj[1] ;
40961
40962 if (!args) SWIG_fail;
40963 swig_obj[0] = args;
40964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40965 if (!SWIG_IsOK(res1)) {
40966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40967 }
40968 arg1 = reinterpret_cast< wxMenu * >(argp1);
40969 {
40970 PyThreadState* __tstate = wxPyBeginAllowThreads();
40971 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40972 wxPyEndAllowThreads(__tstate);
40973 if (PyErr_Occurred()) SWIG_fail;
40974 }
40975 {
40976 resultobj = wxPyMake_wxObject(result, 0);
40977 }
40978 return resultobj;
40979 fail:
40980 return NULL;
40981 }
40982
40983
40984 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40985 PyObject *obj;
40986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40987 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40988 return SWIG_Py_Void();
40989 }
40990
40991 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40992 return SWIG_Python_InitShadowInstance(args);
40993 }
40994
40995 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40996 PyObject *resultobj = 0;
40997 long arg1 = (long) 0 ;
40998 wxMenuBar *result = 0 ;
40999 long val1 ;
41000 int ecode1 = 0 ;
41001 PyObject * obj0 = 0 ;
41002 char * kwnames[] = {
41003 (char *) "style", NULL
41004 };
41005
41006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41007 if (obj0) {
41008 ecode1 = SWIG_AsVal_long(obj0, &val1);
41009 if (!SWIG_IsOK(ecode1)) {
41010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41011 }
41012 arg1 = static_cast< long >(val1);
41013 }
41014 {
41015 if (!wxPyCheckForApp()) SWIG_fail;
41016 PyThreadState* __tstate = wxPyBeginAllowThreads();
41017 result = (wxMenuBar *)new wxMenuBar(arg1);
41018 wxPyEndAllowThreads(__tstate);
41019 if (PyErr_Occurred()) SWIG_fail;
41020 }
41021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41022 return resultobj;
41023 fail:
41024 return NULL;
41025 }
41026
41027
41028 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41029 PyObject *resultobj = 0;
41030 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41031 wxMenu *arg2 = (wxMenu *) 0 ;
41032 wxString *arg3 = 0 ;
41033 bool result;
41034 void *argp1 = 0 ;
41035 int res1 = 0 ;
41036 void *argp2 = 0 ;
41037 int res2 = 0 ;
41038 bool temp3 = false ;
41039 PyObject * obj0 = 0 ;
41040 PyObject * obj1 = 0 ;
41041 PyObject * obj2 = 0 ;
41042 char * kwnames[] = {
41043 (char *) "self",(char *) "menu",(char *) "title", NULL
41044 };
41045
41046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41048 if (!SWIG_IsOK(res1)) {
41049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41050 }
41051 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41053 if (!SWIG_IsOK(res2)) {
41054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41055 }
41056 arg2 = reinterpret_cast< wxMenu * >(argp2);
41057 {
41058 arg3 = wxString_in_helper(obj2);
41059 if (arg3 == NULL) SWIG_fail;
41060 temp3 = true;
41061 }
41062 {
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41065 wxPyEndAllowThreads(__tstate);
41066 if (PyErr_Occurred()) SWIG_fail;
41067 }
41068 {
41069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41070 }
41071 {
41072 if (temp3)
41073 delete arg3;
41074 }
41075 return resultobj;
41076 fail:
41077 {
41078 if (temp3)
41079 delete arg3;
41080 }
41081 return NULL;
41082 }
41083
41084
41085 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41086 PyObject *resultobj = 0;
41087 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41088 size_t arg2 ;
41089 wxMenu *arg3 = (wxMenu *) 0 ;
41090 wxString *arg4 = 0 ;
41091 bool result;
41092 void *argp1 = 0 ;
41093 int res1 = 0 ;
41094 size_t val2 ;
41095 int ecode2 = 0 ;
41096 void *argp3 = 0 ;
41097 int res3 = 0 ;
41098 bool temp4 = false ;
41099 PyObject * obj0 = 0 ;
41100 PyObject * obj1 = 0 ;
41101 PyObject * obj2 = 0 ;
41102 PyObject * obj3 = 0 ;
41103 char * kwnames[] = {
41104 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41105 };
41106
41107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41109 if (!SWIG_IsOK(res1)) {
41110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41111 }
41112 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41113 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41114 if (!SWIG_IsOK(ecode2)) {
41115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41116 }
41117 arg2 = static_cast< size_t >(val2);
41118 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41119 if (!SWIG_IsOK(res3)) {
41120 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41121 }
41122 arg3 = reinterpret_cast< wxMenu * >(argp3);
41123 {
41124 arg4 = wxString_in_helper(obj3);
41125 if (arg4 == NULL) SWIG_fail;
41126 temp4 = true;
41127 }
41128 {
41129 PyThreadState* __tstate = wxPyBeginAllowThreads();
41130 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 {
41135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41136 }
41137 {
41138 if (temp4)
41139 delete arg4;
41140 }
41141 return resultobj;
41142 fail:
41143 {
41144 if (temp4)
41145 delete arg4;
41146 }
41147 return NULL;
41148 }
41149
41150
41151 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41152 PyObject *resultobj = 0;
41153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41154 size_t result;
41155 void *argp1 = 0 ;
41156 int res1 = 0 ;
41157 PyObject *swig_obj[1] ;
41158
41159 if (!args) SWIG_fail;
41160 swig_obj[0] = args;
41161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41162 if (!SWIG_IsOK(res1)) {
41163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41164 }
41165 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41166 {
41167 PyThreadState* __tstate = wxPyBeginAllowThreads();
41168 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41169 wxPyEndAllowThreads(__tstate);
41170 if (PyErr_Occurred()) SWIG_fail;
41171 }
41172 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41173 return resultobj;
41174 fail:
41175 return NULL;
41176 }
41177
41178
41179 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41180 PyObject *resultobj = 0;
41181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41182 size_t arg2 ;
41183 wxMenu *result = 0 ;
41184 void *argp1 = 0 ;
41185 int res1 = 0 ;
41186 size_t val2 ;
41187 int ecode2 = 0 ;
41188 PyObject * obj0 = 0 ;
41189 PyObject * obj1 = 0 ;
41190 char * kwnames[] = {
41191 (char *) "self",(char *) "pos", NULL
41192 };
41193
41194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41196 if (!SWIG_IsOK(res1)) {
41197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41198 }
41199 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41200 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41201 if (!SWIG_IsOK(ecode2)) {
41202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41203 }
41204 arg2 = static_cast< size_t >(val2);
41205 {
41206 PyThreadState* __tstate = wxPyBeginAllowThreads();
41207 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41208 wxPyEndAllowThreads(__tstate);
41209 if (PyErr_Occurred()) SWIG_fail;
41210 }
41211 {
41212 resultobj = wxPyMake_wxObject(result, 0);
41213 }
41214 return resultobj;
41215 fail:
41216 return NULL;
41217 }
41218
41219
41220 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41221 PyObject *resultobj = 0;
41222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41223 size_t arg2 ;
41224 wxMenu *arg3 = (wxMenu *) 0 ;
41225 wxString *arg4 = 0 ;
41226 wxMenu *result = 0 ;
41227 void *argp1 = 0 ;
41228 int res1 = 0 ;
41229 size_t val2 ;
41230 int ecode2 = 0 ;
41231 void *argp3 = 0 ;
41232 int res3 = 0 ;
41233 bool temp4 = false ;
41234 PyObject * obj0 = 0 ;
41235 PyObject * obj1 = 0 ;
41236 PyObject * obj2 = 0 ;
41237 PyObject * obj3 = 0 ;
41238 char * kwnames[] = {
41239 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41240 };
41241
41242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41244 if (!SWIG_IsOK(res1)) {
41245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41246 }
41247 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41248 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41249 if (!SWIG_IsOK(ecode2)) {
41250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41251 }
41252 arg2 = static_cast< size_t >(val2);
41253 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41254 if (!SWIG_IsOK(res3)) {
41255 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41256 }
41257 arg3 = reinterpret_cast< wxMenu * >(argp3);
41258 {
41259 arg4 = wxString_in_helper(obj3);
41260 if (arg4 == NULL) SWIG_fail;
41261 temp4 = true;
41262 }
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 {
41270 resultobj = wxPyMake_wxObject(result, 0);
41271 }
41272 {
41273 if (temp4)
41274 delete arg4;
41275 }
41276 return resultobj;
41277 fail:
41278 {
41279 if (temp4)
41280 delete arg4;
41281 }
41282 return NULL;
41283 }
41284
41285
41286 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj = 0;
41288 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41289 size_t arg2 ;
41290 wxMenu *result = 0 ;
41291 void *argp1 = 0 ;
41292 int res1 = 0 ;
41293 size_t val2 ;
41294 int ecode2 = 0 ;
41295 PyObject * obj0 = 0 ;
41296 PyObject * obj1 = 0 ;
41297 char * kwnames[] = {
41298 (char *) "self",(char *) "pos", NULL
41299 };
41300
41301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41303 if (!SWIG_IsOK(res1)) {
41304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41305 }
41306 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41307 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41308 if (!SWIG_IsOK(ecode2)) {
41309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41310 }
41311 arg2 = static_cast< size_t >(val2);
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = (wxMenu *)(arg1)->Remove(arg2);
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 {
41319 resultobj = wxPyMake_wxObject(result, 0);
41320 }
41321 return resultobj;
41322 fail:
41323 return NULL;
41324 }
41325
41326
41327 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41328 PyObject *resultobj = 0;
41329 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41330 size_t arg2 ;
41331 bool arg3 ;
41332 void *argp1 = 0 ;
41333 int res1 = 0 ;
41334 size_t val2 ;
41335 int ecode2 = 0 ;
41336 bool val3 ;
41337 int ecode3 = 0 ;
41338 PyObject * obj0 = 0 ;
41339 PyObject * obj1 = 0 ;
41340 PyObject * obj2 = 0 ;
41341 char * kwnames[] = {
41342 (char *) "self",(char *) "pos",(char *) "enable", NULL
41343 };
41344
41345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41347 if (!SWIG_IsOK(res1)) {
41348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41349 }
41350 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41351 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41352 if (!SWIG_IsOK(ecode2)) {
41353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41354 }
41355 arg2 = static_cast< size_t >(val2);
41356 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41357 if (!SWIG_IsOK(ecode3)) {
41358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41359 }
41360 arg3 = static_cast< bool >(val3);
41361 {
41362 PyThreadState* __tstate = wxPyBeginAllowThreads();
41363 (arg1)->EnableTop(arg2,arg3);
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 resultobj = SWIG_Py_Void();
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41375 PyObject *resultobj = 0;
41376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41377 size_t arg2 ;
41378 bool result;
41379 void *argp1 = 0 ;
41380 int res1 = 0 ;
41381 size_t val2 ;
41382 int ecode2 = 0 ;
41383 PyObject * obj0 = 0 ;
41384 PyObject * obj1 = 0 ;
41385 char * kwnames[] = {
41386 (char *) "self",(char *) "pos", NULL
41387 };
41388
41389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41391 if (!SWIG_IsOK(res1)) {
41392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41393 }
41394 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41395 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41396 if (!SWIG_IsOK(ecode2)) {
41397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41398 }
41399 arg2 = static_cast< size_t >(val2);
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41403 wxPyEndAllowThreads(__tstate);
41404 if (PyErr_Occurred()) SWIG_fail;
41405 }
41406 {
41407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41408 }
41409 return resultobj;
41410 fail:
41411 return NULL;
41412 }
41413
41414
41415 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41416 PyObject *resultobj = 0;
41417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41418 size_t arg2 ;
41419 wxString *arg3 = 0 ;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 size_t val2 ;
41423 int ecode2 = 0 ;
41424 bool temp3 = false ;
41425 PyObject * obj0 = 0 ;
41426 PyObject * obj1 = 0 ;
41427 PyObject * obj2 = 0 ;
41428 char * kwnames[] = {
41429 (char *) "self",(char *) "pos",(char *) "label", NULL
41430 };
41431
41432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41434 if (!SWIG_IsOK(res1)) {
41435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41436 }
41437 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41438 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41439 if (!SWIG_IsOK(ecode2)) {
41440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41441 }
41442 arg2 = static_cast< size_t >(val2);
41443 {
41444 arg3 = wxString_in_helper(obj2);
41445 if (arg3 == NULL) SWIG_fail;
41446 temp3 = true;
41447 }
41448 {
41449 PyThreadState* __tstate = wxPyBeginAllowThreads();
41450 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41451 wxPyEndAllowThreads(__tstate);
41452 if (PyErr_Occurred()) SWIG_fail;
41453 }
41454 resultobj = SWIG_Py_Void();
41455 {
41456 if (temp3)
41457 delete arg3;
41458 }
41459 return resultobj;
41460 fail:
41461 {
41462 if (temp3)
41463 delete arg3;
41464 }
41465 return NULL;
41466 }
41467
41468
41469 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41470 PyObject *resultobj = 0;
41471 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41472 size_t arg2 ;
41473 wxString result;
41474 void *argp1 = 0 ;
41475 int res1 = 0 ;
41476 size_t val2 ;
41477 int ecode2 = 0 ;
41478 PyObject * obj0 = 0 ;
41479 PyObject * obj1 = 0 ;
41480 char * kwnames[] = {
41481 (char *) "self",(char *) "pos", NULL
41482 };
41483
41484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41486 if (!SWIG_IsOK(res1)) {
41487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41488 }
41489 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41490 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41491 if (!SWIG_IsOK(ecode2)) {
41492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41493 }
41494 arg2 = static_cast< size_t >(val2);
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41498 wxPyEndAllowThreads(__tstate);
41499 if (PyErr_Occurred()) SWIG_fail;
41500 }
41501 {
41502 #if wxUSE_UNICODE
41503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41504 #else
41505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41506 #endif
41507 }
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj = 0;
41516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41517 wxString *arg2 = 0 ;
41518 wxString *arg3 = 0 ;
41519 int result;
41520 void *argp1 = 0 ;
41521 int res1 = 0 ;
41522 bool temp2 = false ;
41523 bool temp3 = false ;
41524 PyObject * obj0 = 0 ;
41525 PyObject * obj1 = 0 ;
41526 PyObject * obj2 = 0 ;
41527 char * kwnames[] = {
41528 (char *) "self",(char *) "menu",(char *) "item", NULL
41529 };
41530
41531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41533 if (!SWIG_IsOK(res1)) {
41534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41535 }
41536 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41537 {
41538 arg2 = wxString_in_helper(obj1);
41539 if (arg2 == NULL) SWIG_fail;
41540 temp2 = true;
41541 }
41542 {
41543 arg3 = wxString_in_helper(obj2);
41544 if (arg3 == NULL) SWIG_fail;
41545 temp3 = true;
41546 }
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 resultobj = SWIG_From_int(static_cast< int >(result));
41554 {
41555 if (temp2)
41556 delete arg2;
41557 }
41558 {
41559 if (temp3)
41560 delete arg3;
41561 }
41562 return resultobj;
41563 fail:
41564 {
41565 if (temp2)
41566 delete arg2;
41567 }
41568 {
41569 if (temp3)
41570 delete arg3;
41571 }
41572 return NULL;
41573 }
41574
41575
41576 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41577 PyObject *resultobj = 0;
41578 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41579 int arg2 ;
41580 wxMenuItem *result = 0 ;
41581 void *argp1 = 0 ;
41582 int res1 = 0 ;
41583 int val2 ;
41584 int ecode2 = 0 ;
41585 PyObject * obj0 = 0 ;
41586 PyObject * obj1 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "id", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41595 }
41596 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41597 ecode2 = SWIG_AsVal_int(obj1, &val2);
41598 if (!SWIG_IsOK(ecode2)) {
41599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41600 }
41601 arg2 = static_cast< int >(val2);
41602 {
41603 PyThreadState* __tstate = wxPyBeginAllowThreads();
41604 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 {
41609 resultobj = wxPyMake_wxObject(result, (bool)0);
41610 }
41611 return resultobj;
41612 fail:
41613 return NULL;
41614 }
41615
41616
41617 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj = 0;
41619 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41620 wxString *arg2 = 0 ;
41621 int result;
41622 void *argp1 = 0 ;
41623 int res1 = 0 ;
41624 bool temp2 = false ;
41625 PyObject * obj0 = 0 ;
41626 PyObject * obj1 = 0 ;
41627 char * kwnames[] = {
41628 (char *) "self",(char *) "title", NULL
41629 };
41630
41631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41635 }
41636 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41637 {
41638 arg2 = wxString_in_helper(obj1);
41639 if (arg2 == NULL) SWIG_fail;
41640 temp2 = true;
41641 }
41642 {
41643 PyThreadState* __tstate = wxPyBeginAllowThreads();
41644 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41645 wxPyEndAllowThreads(__tstate);
41646 if (PyErr_Occurred()) SWIG_fail;
41647 }
41648 resultobj = SWIG_From_int(static_cast< int >(result));
41649 {
41650 if (temp2)
41651 delete arg2;
41652 }
41653 return resultobj;
41654 fail:
41655 {
41656 if (temp2)
41657 delete arg2;
41658 }
41659 return NULL;
41660 }
41661
41662
41663 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41664 PyObject *resultobj = 0;
41665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41666 int arg2 ;
41667 bool arg3 ;
41668 void *argp1 = 0 ;
41669 int res1 = 0 ;
41670 int val2 ;
41671 int ecode2 = 0 ;
41672 bool val3 ;
41673 int ecode3 = 0 ;
41674 PyObject * obj0 = 0 ;
41675 PyObject * obj1 = 0 ;
41676 PyObject * obj2 = 0 ;
41677 char * kwnames[] = {
41678 (char *) "self",(char *) "id",(char *) "enable", NULL
41679 };
41680
41681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41683 if (!SWIG_IsOK(res1)) {
41684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41685 }
41686 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41687 ecode2 = SWIG_AsVal_int(obj1, &val2);
41688 if (!SWIG_IsOK(ecode2)) {
41689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41690 }
41691 arg2 = static_cast< int >(val2);
41692 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41693 if (!SWIG_IsOK(ecode3)) {
41694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41695 }
41696 arg3 = static_cast< bool >(val3);
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 (arg1)->Enable(arg2,arg3);
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 resultobj = SWIG_Py_Void();
41704 return resultobj;
41705 fail:
41706 return NULL;
41707 }
41708
41709
41710 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41711 PyObject *resultobj = 0;
41712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41713 int arg2 ;
41714 bool arg3 ;
41715 void *argp1 = 0 ;
41716 int res1 = 0 ;
41717 int val2 ;
41718 int ecode2 = 0 ;
41719 bool val3 ;
41720 int ecode3 = 0 ;
41721 PyObject * obj0 = 0 ;
41722 PyObject * obj1 = 0 ;
41723 PyObject * obj2 = 0 ;
41724 char * kwnames[] = {
41725 (char *) "self",(char *) "id",(char *) "check", NULL
41726 };
41727
41728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41730 if (!SWIG_IsOK(res1)) {
41731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41732 }
41733 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41734 ecode2 = SWIG_AsVal_int(obj1, &val2);
41735 if (!SWIG_IsOK(ecode2)) {
41736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41737 }
41738 arg2 = static_cast< int >(val2);
41739 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41740 if (!SWIG_IsOK(ecode3)) {
41741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41742 }
41743 arg3 = static_cast< bool >(val3);
41744 {
41745 PyThreadState* __tstate = wxPyBeginAllowThreads();
41746 (arg1)->Check(arg2,arg3);
41747 wxPyEndAllowThreads(__tstate);
41748 if (PyErr_Occurred()) SWIG_fail;
41749 }
41750 resultobj = SWIG_Py_Void();
41751 return resultobj;
41752 fail:
41753 return NULL;
41754 }
41755
41756
41757 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41758 PyObject *resultobj = 0;
41759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41760 int arg2 ;
41761 bool result;
41762 void *argp1 = 0 ;
41763 int res1 = 0 ;
41764 int val2 ;
41765 int ecode2 = 0 ;
41766 PyObject * obj0 = 0 ;
41767 PyObject * obj1 = 0 ;
41768 char * kwnames[] = {
41769 (char *) "self",(char *) "id", NULL
41770 };
41771
41772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41774 if (!SWIG_IsOK(res1)) {
41775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41776 }
41777 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41778 ecode2 = SWIG_AsVal_int(obj1, &val2);
41779 if (!SWIG_IsOK(ecode2)) {
41780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41781 }
41782 arg2 = static_cast< int >(val2);
41783 {
41784 PyThreadState* __tstate = wxPyBeginAllowThreads();
41785 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 {
41790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41791 }
41792 return resultobj;
41793 fail:
41794 return NULL;
41795 }
41796
41797
41798 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41799 PyObject *resultobj = 0;
41800 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41801 int arg2 ;
41802 bool result;
41803 void *argp1 = 0 ;
41804 int res1 = 0 ;
41805 int val2 ;
41806 int ecode2 = 0 ;
41807 PyObject * obj0 = 0 ;
41808 PyObject * obj1 = 0 ;
41809 char * kwnames[] = {
41810 (char *) "self",(char *) "id", NULL
41811 };
41812
41813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41815 if (!SWIG_IsOK(res1)) {
41816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41817 }
41818 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41819 ecode2 = SWIG_AsVal_int(obj1, &val2);
41820 if (!SWIG_IsOK(ecode2)) {
41821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41822 }
41823 arg2 = static_cast< int >(val2);
41824 {
41825 PyThreadState* __tstate = wxPyBeginAllowThreads();
41826 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41827 wxPyEndAllowThreads(__tstate);
41828 if (PyErr_Occurred()) SWIG_fail;
41829 }
41830 {
41831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41832 }
41833 return resultobj;
41834 fail:
41835 return NULL;
41836 }
41837
41838
41839 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj = 0;
41841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41842 int arg2 ;
41843 wxString *arg3 = 0 ;
41844 void *argp1 = 0 ;
41845 int res1 = 0 ;
41846 int val2 ;
41847 int ecode2 = 0 ;
41848 bool temp3 = false ;
41849 PyObject * obj0 = 0 ;
41850 PyObject * obj1 = 0 ;
41851 PyObject * obj2 = 0 ;
41852 char * kwnames[] = {
41853 (char *) "self",(char *) "id",(char *) "label", NULL
41854 };
41855
41856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41858 if (!SWIG_IsOK(res1)) {
41859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41860 }
41861 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41862 ecode2 = SWIG_AsVal_int(obj1, &val2);
41863 if (!SWIG_IsOK(ecode2)) {
41864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41865 }
41866 arg2 = static_cast< int >(val2);
41867 {
41868 arg3 = wxString_in_helper(obj2);
41869 if (arg3 == NULL) SWIG_fail;
41870 temp3 = true;
41871 }
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 resultobj = SWIG_Py_Void();
41879 {
41880 if (temp3)
41881 delete arg3;
41882 }
41883 return resultobj;
41884 fail:
41885 {
41886 if (temp3)
41887 delete arg3;
41888 }
41889 return NULL;
41890 }
41891
41892
41893 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj = 0;
41895 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41896 int arg2 ;
41897 wxString result;
41898 void *argp1 = 0 ;
41899 int res1 = 0 ;
41900 int val2 ;
41901 int ecode2 = 0 ;
41902 PyObject * obj0 = 0 ;
41903 PyObject * obj1 = 0 ;
41904 char * kwnames[] = {
41905 (char *) "self",(char *) "id", NULL
41906 };
41907
41908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41910 if (!SWIG_IsOK(res1)) {
41911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41912 }
41913 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41914 ecode2 = SWIG_AsVal_int(obj1, &val2);
41915 if (!SWIG_IsOK(ecode2)) {
41916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41917 }
41918 arg2 = static_cast< int >(val2);
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41922 wxPyEndAllowThreads(__tstate);
41923 if (PyErr_Occurred()) SWIG_fail;
41924 }
41925 {
41926 #if wxUSE_UNICODE
41927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41928 #else
41929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41930 #endif
41931 }
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj = 0;
41940 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41941 int arg2 ;
41942 wxString *arg3 = 0 ;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 int val2 ;
41946 int ecode2 = 0 ;
41947 bool temp3 = false ;
41948 PyObject * obj0 = 0 ;
41949 PyObject * obj1 = 0 ;
41950 PyObject * obj2 = 0 ;
41951 char * kwnames[] = {
41952 (char *) "self",(char *) "id",(char *) "helpString", NULL
41953 };
41954
41955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41957 if (!SWIG_IsOK(res1)) {
41958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41959 }
41960 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41961 ecode2 = SWIG_AsVal_int(obj1, &val2);
41962 if (!SWIG_IsOK(ecode2)) {
41963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41964 }
41965 arg2 = static_cast< int >(val2);
41966 {
41967 arg3 = wxString_in_helper(obj2);
41968 if (arg3 == NULL) SWIG_fail;
41969 temp3 = true;
41970 }
41971 {
41972 PyThreadState* __tstate = wxPyBeginAllowThreads();
41973 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41974 wxPyEndAllowThreads(__tstate);
41975 if (PyErr_Occurred()) SWIG_fail;
41976 }
41977 resultobj = SWIG_Py_Void();
41978 {
41979 if (temp3)
41980 delete arg3;
41981 }
41982 return resultobj;
41983 fail:
41984 {
41985 if (temp3)
41986 delete arg3;
41987 }
41988 return NULL;
41989 }
41990
41991
41992 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41993 PyObject *resultobj = 0;
41994 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41995 int arg2 ;
41996 wxString result;
41997 void *argp1 = 0 ;
41998 int res1 = 0 ;
41999 int val2 ;
42000 int ecode2 = 0 ;
42001 PyObject * obj0 = 0 ;
42002 PyObject * obj1 = 0 ;
42003 char * kwnames[] = {
42004 (char *) "self",(char *) "id", NULL
42005 };
42006
42007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42009 if (!SWIG_IsOK(res1)) {
42010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42011 }
42012 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42013 ecode2 = SWIG_AsVal_int(obj1, &val2);
42014 if (!SWIG_IsOK(ecode2)) {
42015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42016 }
42017 arg2 = static_cast< int >(val2);
42018 {
42019 PyThreadState* __tstate = wxPyBeginAllowThreads();
42020 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42021 wxPyEndAllowThreads(__tstate);
42022 if (PyErr_Occurred()) SWIG_fail;
42023 }
42024 {
42025 #if wxUSE_UNICODE
42026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42027 #else
42028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42029 #endif
42030 }
42031 return resultobj;
42032 fail:
42033 return NULL;
42034 }
42035
42036
42037 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42038 PyObject *resultobj = 0;
42039 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42040 wxFrame *result = 0 ;
42041 void *argp1 = 0 ;
42042 int res1 = 0 ;
42043 PyObject *swig_obj[1] ;
42044
42045 if (!args) SWIG_fail;
42046 swig_obj[0] = args;
42047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42048 if (!SWIG_IsOK(res1)) {
42049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42050 }
42051 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42055 wxPyEndAllowThreads(__tstate);
42056 if (PyErr_Occurred()) SWIG_fail;
42057 }
42058 {
42059 resultobj = wxPyMake_wxObject(result, (bool)0);
42060 }
42061 return resultobj;
42062 fail:
42063 return NULL;
42064 }
42065
42066
42067 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42068 PyObject *resultobj = 0;
42069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42070 bool result;
42071 void *argp1 = 0 ;
42072 int res1 = 0 ;
42073 PyObject *swig_obj[1] ;
42074
42075 if (!args) SWIG_fail;
42076 swig_obj[0] = args;
42077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42078 if (!SWIG_IsOK(res1)) {
42079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42080 }
42081 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42085 wxPyEndAllowThreads(__tstate);
42086 if (PyErr_Occurred()) SWIG_fail;
42087 }
42088 {
42089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42090 }
42091 return resultobj;
42092 fail:
42093 return NULL;
42094 }
42095
42096
42097 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42098 PyObject *resultobj = 0;
42099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42100 wxFrame *arg2 = (wxFrame *) 0 ;
42101 void *argp1 = 0 ;
42102 int res1 = 0 ;
42103 void *argp2 = 0 ;
42104 int res2 = 0 ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 char * kwnames[] = {
42108 (char *) "self",(char *) "frame", NULL
42109 };
42110
42111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42113 if (!SWIG_IsOK(res1)) {
42114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42115 }
42116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42118 if (!SWIG_IsOK(res2)) {
42119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42120 }
42121 arg2 = reinterpret_cast< wxFrame * >(argp2);
42122 {
42123 PyThreadState* __tstate = wxPyBeginAllowThreads();
42124 (arg1)->Attach(arg2);
42125 wxPyEndAllowThreads(__tstate);
42126 if (PyErr_Occurred()) SWIG_fail;
42127 }
42128 resultobj = SWIG_Py_Void();
42129 return resultobj;
42130 fail:
42131 return NULL;
42132 }
42133
42134
42135 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42136 PyObject *resultobj = 0;
42137 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42138 void *argp1 = 0 ;
42139 int res1 = 0 ;
42140 PyObject *swig_obj[1] ;
42141
42142 if (!args) SWIG_fail;
42143 swig_obj[0] = args;
42144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42145 if (!SWIG_IsOK(res1)) {
42146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42147 }
42148 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42149 {
42150 PyThreadState* __tstate = wxPyBeginAllowThreads();
42151 (arg1)->Detach();
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 resultobj = SWIG_Py_Void();
42156 return resultobj;
42157 fail:
42158 return NULL;
42159 }
42160
42161
42162 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42163 PyObject *resultobj = 0;
42164 bool arg1 ;
42165 bool val1 ;
42166 int ecode1 = 0 ;
42167 PyObject * obj0 = 0 ;
42168 char * kwnames[] = {
42169 (char *) "enable", NULL
42170 };
42171
42172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42173 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42174 if (!SWIG_IsOK(ecode1)) {
42175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42176 }
42177 arg1 = static_cast< bool >(val1);
42178 {
42179 PyThreadState* __tstate = wxPyBeginAllowThreads();
42180 wxMenuBar_SetAutoWindowMenu(arg1);
42181 wxPyEndAllowThreads(__tstate);
42182 if (PyErr_Occurred()) SWIG_fail;
42183 }
42184 resultobj = SWIG_Py_Void();
42185 return resultobj;
42186 fail:
42187 return NULL;
42188 }
42189
42190
42191 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42192 PyObject *resultobj = 0;
42193 bool result;
42194
42195 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 result = (bool)wxMenuBar_GetAutoWindowMenu();
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 {
42203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42204 }
42205 return resultobj;
42206 fail:
42207 return NULL;
42208 }
42209
42210
42211 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42212 PyObject *obj;
42213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42214 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42215 return SWIG_Py_Void();
42216 }
42217
42218 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42219 return SWIG_Python_InitShadowInstance(args);
42220 }
42221
42222 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42223 PyObject *resultobj = 0;
42224 wxMenu *arg1 = (wxMenu *) NULL ;
42225 int arg2 = (int) wxID_ANY ;
42226 wxString const &arg3_defvalue = wxPyEmptyString ;
42227 wxString *arg3 = (wxString *) &arg3_defvalue ;
42228 wxString const &arg4_defvalue = wxPyEmptyString ;
42229 wxString *arg4 = (wxString *) &arg4_defvalue ;
42230 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42231 wxMenu *arg6 = (wxMenu *) NULL ;
42232 wxMenuItem *result = 0 ;
42233 void *argp1 = 0 ;
42234 int res1 = 0 ;
42235 int val2 ;
42236 int ecode2 = 0 ;
42237 bool temp3 = false ;
42238 bool temp4 = false ;
42239 int val5 ;
42240 int ecode5 = 0 ;
42241 void *argp6 = 0 ;
42242 int res6 = 0 ;
42243 PyObject * obj0 = 0 ;
42244 PyObject * obj1 = 0 ;
42245 PyObject * obj2 = 0 ;
42246 PyObject * obj3 = 0 ;
42247 PyObject * obj4 = 0 ;
42248 PyObject * obj5 = 0 ;
42249 char * kwnames[] = {
42250 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42251 };
42252
42253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42254 if (obj0) {
42255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42256 if (!SWIG_IsOK(res1)) {
42257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42258 }
42259 arg1 = reinterpret_cast< wxMenu * >(argp1);
42260 }
42261 if (obj1) {
42262 ecode2 = SWIG_AsVal_int(obj1, &val2);
42263 if (!SWIG_IsOK(ecode2)) {
42264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42265 }
42266 arg2 = static_cast< int >(val2);
42267 }
42268 if (obj2) {
42269 {
42270 arg3 = wxString_in_helper(obj2);
42271 if (arg3 == NULL) SWIG_fail;
42272 temp3 = true;
42273 }
42274 }
42275 if (obj3) {
42276 {
42277 arg4 = wxString_in_helper(obj3);
42278 if (arg4 == NULL) SWIG_fail;
42279 temp4 = true;
42280 }
42281 }
42282 if (obj4) {
42283 ecode5 = SWIG_AsVal_int(obj4, &val5);
42284 if (!SWIG_IsOK(ecode5)) {
42285 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42286 }
42287 arg5 = static_cast< wxItemKind >(val5);
42288 }
42289 if (obj5) {
42290 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42291 if (!SWIG_IsOK(res6)) {
42292 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42293 }
42294 arg6 = reinterpret_cast< wxMenu * >(argp6);
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42304 }
42305 {
42306 if (temp3)
42307 delete arg3;
42308 }
42309 {
42310 if (temp4)
42311 delete arg4;
42312 }
42313 return resultobj;
42314 fail:
42315 {
42316 if (temp3)
42317 delete arg3;
42318 }
42319 {
42320 if (temp4)
42321 delete arg4;
42322 }
42323 return NULL;
42324 }
42325
42326
42327 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42328 PyObject *resultobj = 0;
42329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42330 void *argp1 = 0 ;
42331 int res1 = 0 ;
42332 PyObject *swig_obj[1] ;
42333
42334 if (!args) SWIG_fail;
42335 swig_obj[0] = args;
42336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42337 if (!SWIG_IsOK(res1)) {
42338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42339 }
42340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42341 {
42342 PyThreadState* __tstate = wxPyBeginAllowThreads();
42343 delete arg1;
42344
42345 wxPyEndAllowThreads(__tstate);
42346 if (PyErr_Occurred()) SWIG_fail;
42347 }
42348 resultobj = SWIG_Py_Void();
42349 return resultobj;
42350 fail:
42351 return NULL;
42352 }
42353
42354
42355 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42356 PyObject *resultobj = 0;
42357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42358 wxMenu *result = 0 ;
42359 void *argp1 = 0 ;
42360 int res1 = 0 ;
42361 PyObject *swig_obj[1] ;
42362
42363 if (!args) SWIG_fail;
42364 swig_obj[0] = args;
42365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42366 if (!SWIG_IsOK(res1)) {
42367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42368 }
42369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42373 wxPyEndAllowThreads(__tstate);
42374 if (PyErr_Occurred()) SWIG_fail;
42375 }
42376 {
42377 resultobj = wxPyMake_wxObject(result, 0);
42378 }
42379 return resultobj;
42380 fail:
42381 return NULL;
42382 }
42383
42384
42385 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42386 PyObject *resultobj = 0;
42387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42388 wxMenu *arg2 = (wxMenu *) 0 ;
42389 void *argp1 = 0 ;
42390 int res1 = 0 ;
42391 void *argp2 = 0 ;
42392 int res2 = 0 ;
42393 PyObject * obj0 = 0 ;
42394 PyObject * obj1 = 0 ;
42395 char * kwnames[] = {
42396 (char *) "self",(char *) "menu", NULL
42397 };
42398
42399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42401 if (!SWIG_IsOK(res1)) {
42402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42403 }
42404 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42406 if (!SWIG_IsOK(res2)) {
42407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42408 }
42409 arg2 = reinterpret_cast< wxMenu * >(argp2);
42410 {
42411 PyThreadState* __tstate = wxPyBeginAllowThreads();
42412 (arg1)->SetMenu(arg2);
42413 wxPyEndAllowThreads(__tstate);
42414 if (PyErr_Occurred()) SWIG_fail;
42415 }
42416 resultobj = SWIG_Py_Void();
42417 return resultobj;
42418 fail:
42419 return NULL;
42420 }
42421
42422
42423 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42424 PyObject *resultobj = 0;
42425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42426 int arg2 ;
42427 void *argp1 = 0 ;
42428 int res1 = 0 ;
42429 int val2 ;
42430 int ecode2 = 0 ;
42431 PyObject * obj0 = 0 ;
42432 PyObject * obj1 = 0 ;
42433 char * kwnames[] = {
42434 (char *) "self",(char *) "id", NULL
42435 };
42436
42437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42439 if (!SWIG_IsOK(res1)) {
42440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42441 }
42442 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42443 ecode2 = SWIG_AsVal_int(obj1, &val2);
42444 if (!SWIG_IsOK(ecode2)) {
42445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42446 }
42447 arg2 = static_cast< int >(val2);
42448 {
42449 PyThreadState* __tstate = wxPyBeginAllowThreads();
42450 (arg1)->SetId(arg2);
42451 wxPyEndAllowThreads(__tstate);
42452 if (PyErr_Occurred()) SWIG_fail;
42453 }
42454 resultobj = SWIG_Py_Void();
42455 return resultobj;
42456 fail:
42457 return NULL;
42458 }
42459
42460
42461 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42462 PyObject *resultobj = 0;
42463 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42464 int result;
42465 void *argp1 = 0 ;
42466 int res1 = 0 ;
42467 PyObject *swig_obj[1] ;
42468
42469 if (!args) SWIG_fail;
42470 swig_obj[0] = args;
42471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42472 if (!SWIG_IsOK(res1)) {
42473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42474 }
42475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (int)((wxMenuItem const *)arg1)->GetId();
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 resultobj = SWIG_From_int(static_cast< int >(result));
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42490 PyObject *resultobj = 0;
42491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42492 bool result;
42493 void *argp1 = 0 ;
42494 int res1 = 0 ;
42495 PyObject *swig_obj[1] ;
42496
42497 if (!args) SWIG_fail;
42498 swig_obj[0] = args;
42499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42500 if (!SWIG_IsOK(res1)) {
42501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42502 }
42503 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42504 {
42505 PyThreadState* __tstate = wxPyBeginAllowThreads();
42506 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42507 wxPyEndAllowThreads(__tstate);
42508 if (PyErr_Occurred()) SWIG_fail;
42509 }
42510 {
42511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42512 }
42513 return resultobj;
42514 fail:
42515 return NULL;
42516 }
42517
42518
42519 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42520 PyObject *resultobj = 0;
42521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42522 wxString *arg2 = 0 ;
42523 void *argp1 = 0 ;
42524 int res1 = 0 ;
42525 bool temp2 = false ;
42526 PyObject * obj0 = 0 ;
42527 PyObject * obj1 = 0 ;
42528 char * kwnames[] = {
42529 (char *) "self",(char *) "str", NULL
42530 };
42531
42532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42534 if (!SWIG_IsOK(res1)) {
42535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42536 }
42537 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42538 {
42539 arg2 = wxString_in_helper(obj1);
42540 if (arg2 == NULL) SWIG_fail;
42541 temp2 = true;
42542 }
42543 {
42544 PyThreadState* __tstate = wxPyBeginAllowThreads();
42545 (arg1)->SetText((wxString const &)*arg2);
42546 wxPyEndAllowThreads(__tstate);
42547 if (PyErr_Occurred()) SWIG_fail;
42548 }
42549 resultobj = SWIG_Py_Void();
42550 {
42551 if (temp2)
42552 delete arg2;
42553 }
42554 return resultobj;
42555 fail:
42556 {
42557 if (temp2)
42558 delete arg2;
42559 }
42560 return NULL;
42561 }
42562
42563
42564 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42565 PyObject *resultobj = 0;
42566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42567 wxString result;
42568 void *argp1 = 0 ;
42569 int res1 = 0 ;
42570 PyObject *swig_obj[1] ;
42571
42572 if (!args) SWIG_fail;
42573 swig_obj[0] = args;
42574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42575 if (!SWIG_IsOK(res1)) {
42576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42577 }
42578 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42579 {
42580 PyThreadState* __tstate = wxPyBeginAllowThreads();
42581 result = ((wxMenuItem const *)arg1)->GetLabel();
42582 wxPyEndAllowThreads(__tstate);
42583 if (PyErr_Occurred()) SWIG_fail;
42584 }
42585 {
42586 #if wxUSE_UNICODE
42587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42588 #else
42589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42590 #endif
42591 }
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42599 PyObject *resultobj = 0;
42600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42601 wxString *result = 0 ;
42602 void *argp1 = 0 ;
42603 int res1 = 0 ;
42604 PyObject *swig_obj[1] ;
42605
42606 if (!args) SWIG_fail;
42607 swig_obj[0] = args;
42608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42609 if (!SWIG_IsOK(res1)) {
42610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42611 }
42612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 {
42616 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42617 result = (wxString *) &_result_ref;
42618 }
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 #if wxUSE_UNICODE
42624 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42625 #else
42626 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42627 #endif
42628 }
42629 return resultobj;
42630 fail:
42631 return NULL;
42632 }
42633
42634
42635 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42636 PyObject *resultobj = 0;
42637 wxString *arg1 = 0 ;
42638 wxString result;
42639 bool temp1 = false ;
42640 PyObject * obj0 = 0 ;
42641 char * kwnames[] = {
42642 (char *) "text", NULL
42643 };
42644
42645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42646 {
42647 arg1 = wxString_in_helper(obj0);
42648 if (arg1 == NULL) SWIG_fail;
42649 temp1 = true;
42650 }
42651 {
42652 PyThreadState* __tstate = wxPyBeginAllowThreads();
42653 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 {
42658 #if wxUSE_UNICODE
42659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42660 #else
42661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42662 #endif
42663 }
42664 {
42665 if (temp1)
42666 delete arg1;
42667 }
42668 return resultobj;
42669 fail:
42670 {
42671 if (temp1)
42672 delete arg1;
42673 }
42674 return NULL;
42675 }
42676
42677
42678 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42679 PyObject *resultobj = 0;
42680 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42681 wxItemKind result;
42682 void *argp1 = 0 ;
42683 int res1 = 0 ;
42684 PyObject *swig_obj[1] ;
42685
42686 if (!args) SWIG_fail;
42687 swig_obj[0] = args;
42688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42689 if (!SWIG_IsOK(res1)) {
42690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42691 }
42692 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42693 {
42694 PyThreadState* __tstate = wxPyBeginAllowThreads();
42695 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42696 wxPyEndAllowThreads(__tstate);
42697 if (PyErr_Occurred()) SWIG_fail;
42698 }
42699 resultobj = SWIG_From_int(static_cast< int >(result));
42700 return resultobj;
42701 fail:
42702 return NULL;
42703 }
42704
42705
42706 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42707 PyObject *resultobj = 0;
42708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42709 wxItemKind arg2 ;
42710 void *argp1 = 0 ;
42711 int res1 = 0 ;
42712 int val2 ;
42713 int ecode2 = 0 ;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 char * kwnames[] = {
42717 (char *) "self",(char *) "kind", NULL
42718 };
42719
42720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42722 if (!SWIG_IsOK(res1)) {
42723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42724 }
42725 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42726 ecode2 = SWIG_AsVal_int(obj1, &val2);
42727 if (!SWIG_IsOK(ecode2)) {
42728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42729 }
42730 arg2 = static_cast< wxItemKind >(val2);
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 (arg1)->SetKind(arg2);
42734 wxPyEndAllowThreads(__tstate);
42735 if (PyErr_Occurred()) SWIG_fail;
42736 }
42737 resultobj = SWIG_Py_Void();
42738 return resultobj;
42739 fail:
42740 return NULL;
42741 }
42742
42743
42744 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42745 PyObject *resultobj = 0;
42746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42747 bool arg2 ;
42748 void *argp1 = 0 ;
42749 int res1 = 0 ;
42750 bool val2 ;
42751 int ecode2 = 0 ;
42752 PyObject * obj0 = 0 ;
42753 PyObject * obj1 = 0 ;
42754 char * kwnames[] = {
42755 (char *) "self",(char *) "checkable", NULL
42756 };
42757
42758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42760 if (!SWIG_IsOK(res1)) {
42761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42762 }
42763 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42765 if (!SWIG_IsOK(ecode2)) {
42766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42767 }
42768 arg2 = static_cast< bool >(val2);
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 (arg1)->SetCheckable(arg2);
42772 wxPyEndAllowThreads(__tstate);
42773 if (PyErr_Occurred()) SWIG_fail;
42774 }
42775 resultobj = SWIG_Py_Void();
42776 return resultobj;
42777 fail:
42778 return NULL;
42779 }
42780
42781
42782 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42783 PyObject *resultobj = 0;
42784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42785 bool result;
42786 void *argp1 = 0 ;
42787 int res1 = 0 ;
42788 PyObject *swig_obj[1] ;
42789
42790 if (!args) SWIG_fail;
42791 swig_obj[0] = args;
42792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42793 if (!SWIG_IsOK(res1)) {
42794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42795 }
42796 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42797 {
42798 PyThreadState* __tstate = wxPyBeginAllowThreads();
42799 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 {
42804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42805 }
42806 return resultobj;
42807 fail:
42808 return NULL;
42809 }
42810
42811
42812 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42813 PyObject *resultobj = 0;
42814 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42815 bool result;
42816 void *argp1 = 0 ;
42817 int res1 = 0 ;
42818 PyObject *swig_obj[1] ;
42819
42820 if (!args) SWIG_fail;
42821 swig_obj[0] = args;
42822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42823 if (!SWIG_IsOK(res1)) {
42824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42825 }
42826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42827 {
42828 PyThreadState* __tstate = wxPyBeginAllowThreads();
42829 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42830 wxPyEndAllowThreads(__tstate);
42831 if (PyErr_Occurred()) SWIG_fail;
42832 }
42833 {
42834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42835 }
42836 return resultobj;
42837 fail:
42838 return NULL;
42839 }
42840
42841
42842 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42843 PyObject *resultobj = 0;
42844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42845 wxMenu *arg2 = (wxMenu *) 0 ;
42846 void *argp1 = 0 ;
42847 int res1 = 0 ;
42848 void *argp2 = 0 ;
42849 int res2 = 0 ;
42850 PyObject * obj0 = 0 ;
42851 PyObject * obj1 = 0 ;
42852 char * kwnames[] = {
42853 (char *) "self",(char *) "menu", NULL
42854 };
42855
42856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42858 if (!SWIG_IsOK(res1)) {
42859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42860 }
42861 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42863 if (!SWIG_IsOK(res2)) {
42864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42865 }
42866 arg2 = reinterpret_cast< wxMenu * >(argp2);
42867 {
42868 PyThreadState* __tstate = wxPyBeginAllowThreads();
42869 (arg1)->SetSubMenu(arg2);
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 resultobj = SWIG_Py_Void();
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42881 PyObject *resultobj = 0;
42882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42883 wxMenu *result = 0 ;
42884 void *argp1 = 0 ;
42885 int res1 = 0 ;
42886 PyObject *swig_obj[1] ;
42887
42888 if (!args) SWIG_fail;
42889 swig_obj[0] = args;
42890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42891 if (!SWIG_IsOK(res1)) {
42892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42893 }
42894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42895 {
42896 PyThreadState* __tstate = wxPyBeginAllowThreads();
42897 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42898 wxPyEndAllowThreads(__tstate);
42899 if (PyErr_Occurred()) SWIG_fail;
42900 }
42901 {
42902 resultobj = wxPyMake_wxObject(result, 0);
42903 }
42904 return resultobj;
42905 fail:
42906 return NULL;
42907 }
42908
42909
42910 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42911 PyObject *resultobj = 0;
42912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42913 bool arg2 = (bool) true ;
42914 void *argp1 = 0 ;
42915 int res1 = 0 ;
42916 bool val2 ;
42917 int ecode2 = 0 ;
42918 PyObject * obj0 = 0 ;
42919 PyObject * obj1 = 0 ;
42920 char * kwnames[] = {
42921 (char *) "self",(char *) "enable", NULL
42922 };
42923
42924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42926 if (!SWIG_IsOK(res1)) {
42927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42928 }
42929 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42930 if (obj1) {
42931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42932 if (!SWIG_IsOK(ecode2)) {
42933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42934 }
42935 arg2 = static_cast< bool >(val2);
42936 }
42937 {
42938 PyThreadState* __tstate = wxPyBeginAllowThreads();
42939 (arg1)->Enable(arg2);
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 resultobj = SWIG_Py_Void();
42944 return resultobj;
42945 fail:
42946 return NULL;
42947 }
42948
42949
42950 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42951 PyObject *resultobj = 0;
42952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42953 bool result;
42954 void *argp1 = 0 ;
42955 int res1 = 0 ;
42956 PyObject *swig_obj[1] ;
42957
42958 if (!args) SWIG_fail;
42959 swig_obj[0] = args;
42960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42961 if (!SWIG_IsOK(res1)) {
42962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42963 }
42964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42965 {
42966 PyThreadState* __tstate = wxPyBeginAllowThreads();
42967 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42968 wxPyEndAllowThreads(__tstate);
42969 if (PyErr_Occurred()) SWIG_fail;
42970 }
42971 {
42972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42973 }
42974 return resultobj;
42975 fail:
42976 return NULL;
42977 }
42978
42979
42980 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42981 PyObject *resultobj = 0;
42982 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42983 bool arg2 = (bool) true ;
42984 void *argp1 = 0 ;
42985 int res1 = 0 ;
42986 bool val2 ;
42987 int ecode2 = 0 ;
42988 PyObject * obj0 = 0 ;
42989 PyObject * obj1 = 0 ;
42990 char * kwnames[] = {
42991 (char *) "self",(char *) "check", NULL
42992 };
42993
42994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42996 if (!SWIG_IsOK(res1)) {
42997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42998 }
42999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43000 if (obj1) {
43001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43002 if (!SWIG_IsOK(ecode2)) {
43003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43004 }
43005 arg2 = static_cast< bool >(val2);
43006 }
43007 {
43008 PyThreadState* __tstate = wxPyBeginAllowThreads();
43009 (arg1)->Check(arg2);
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 resultobj = SWIG_Py_Void();
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43021 PyObject *resultobj = 0;
43022 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43023 bool result;
43024 void *argp1 = 0 ;
43025 int res1 = 0 ;
43026 PyObject *swig_obj[1] ;
43027
43028 if (!args) SWIG_fail;
43029 swig_obj[0] = args;
43030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43031 if (!SWIG_IsOK(res1)) {
43032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43033 }
43034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43035 {
43036 PyThreadState* __tstate = wxPyBeginAllowThreads();
43037 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43038 wxPyEndAllowThreads(__tstate);
43039 if (PyErr_Occurred()) SWIG_fail;
43040 }
43041 {
43042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43043 }
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43051 PyObject *resultobj = 0;
43052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43053 void *argp1 = 0 ;
43054 int res1 = 0 ;
43055 PyObject *swig_obj[1] ;
43056
43057 if (!args) SWIG_fail;
43058 swig_obj[0] = args;
43059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43060 if (!SWIG_IsOK(res1)) {
43061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43062 }
43063 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43064 {
43065 PyThreadState* __tstate = wxPyBeginAllowThreads();
43066 (arg1)->Toggle();
43067 wxPyEndAllowThreads(__tstate);
43068 if (PyErr_Occurred()) SWIG_fail;
43069 }
43070 resultobj = SWIG_Py_Void();
43071 return resultobj;
43072 fail:
43073 return NULL;
43074 }
43075
43076
43077 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43078 PyObject *resultobj = 0;
43079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43080 wxString *arg2 = 0 ;
43081 void *argp1 = 0 ;
43082 int res1 = 0 ;
43083 bool temp2 = false ;
43084 PyObject * obj0 = 0 ;
43085 PyObject * obj1 = 0 ;
43086 char * kwnames[] = {
43087 (char *) "self",(char *) "str", NULL
43088 };
43089
43090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43092 if (!SWIG_IsOK(res1)) {
43093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43094 }
43095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43096 {
43097 arg2 = wxString_in_helper(obj1);
43098 if (arg2 == NULL) SWIG_fail;
43099 temp2 = true;
43100 }
43101 {
43102 PyThreadState* __tstate = wxPyBeginAllowThreads();
43103 (arg1)->SetHelp((wxString const &)*arg2);
43104 wxPyEndAllowThreads(__tstate);
43105 if (PyErr_Occurred()) SWIG_fail;
43106 }
43107 resultobj = SWIG_Py_Void();
43108 {
43109 if (temp2)
43110 delete arg2;
43111 }
43112 return resultobj;
43113 fail:
43114 {
43115 if (temp2)
43116 delete arg2;
43117 }
43118 return NULL;
43119 }
43120
43121
43122 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43123 PyObject *resultobj = 0;
43124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43125 wxString *result = 0 ;
43126 void *argp1 = 0 ;
43127 int res1 = 0 ;
43128 PyObject *swig_obj[1] ;
43129
43130 if (!args) SWIG_fail;
43131 swig_obj[0] = args;
43132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43133 if (!SWIG_IsOK(res1)) {
43134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43135 }
43136 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43137 {
43138 PyThreadState* __tstate = wxPyBeginAllowThreads();
43139 {
43140 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43141 result = (wxString *) &_result_ref;
43142 }
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 {
43147 #if wxUSE_UNICODE
43148 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43149 #else
43150 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43151 #endif
43152 }
43153 return resultobj;
43154 fail:
43155 return NULL;
43156 }
43157
43158
43159 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43160 PyObject *resultobj = 0;
43161 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43162 wxAcceleratorEntry *result = 0 ;
43163 void *argp1 = 0 ;
43164 int res1 = 0 ;
43165 PyObject *swig_obj[1] ;
43166
43167 if (!args) SWIG_fail;
43168 swig_obj[0] = args;
43169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43170 if (!SWIG_IsOK(res1)) {
43171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43172 }
43173 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43174 {
43175 PyThreadState* __tstate = wxPyBeginAllowThreads();
43176 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43177 wxPyEndAllowThreads(__tstate);
43178 if (PyErr_Occurred()) SWIG_fail;
43179 }
43180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43181 return resultobj;
43182 fail:
43183 return NULL;
43184 }
43185
43186
43187 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43188 PyObject *resultobj = 0;
43189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43190 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43191 void *argp1 = 0 ;
43192 int res1 = 0 ;
43193 void *argp2 = 0 ;
43194 int res2 = 0 ;
43195 PyObject * obj0 = 0 ;
43196 PyObject * obj1 = 0 ;
43197 char * kwnames[] = {
43198 (char *) "self",(char *) "accel", NULL
43199 };
43200
43201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43203 if (!SWIG_IsOK(res1)) {
43204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43205 }
43206 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43208 if (!SWIG_IsOK(res2)) {
43209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43210 }
43211 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 (arg1)->SetAccel(arg2);
43215 wxPyEndAllowThreads(__tstate);
43216 if (PyErr_Occurred()) SWIG_fail;
43217 }
43218 resultobj = SWIG_Py_Void();
43219 return resultobj;
43220 fail:
43221 return NULL;
43222 }
43223
43224
43225 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43226 PyObject *resultobj = 0;
43227 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43228 wxBitmap *arg2 = 0 ;
43229 void *argp1 = 0 ;
43230 int res1 = 0 ;
43231 void *argp2 = 0 ;
43232 int res2 = 0 ;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 char * kwnames[] = {
43236 (char *) "self",(char *) "bitmap", NULL
43237 };
43238
43239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43241 if (!SWIG_IsOK(res1)) {
43242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43243 }
43244 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43246 if (!SWIG_IsOK(res2)) {
43247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43248 }
43249 if (!argp2) {
43250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43251 }
43252 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43253 {
43254 PyThreadState* __tstate = wxPyBeginAllowThreads();
43255 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43256 wxPyEndAllowThreads(__tstate);
43257 if (PyErr_Occurred()) SWIG_fail;
43258 }
43259 resultobj = SWIG_Py_Void();
43260 return resultobj;
43261 fail:
43262 return NULL;
43263 }
43264
43265
43266 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43267 PyObject *resultobj = 0;
43268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43269 wxBitmap *result = 0 ;
43270 void *argp1 = 0 ;
43271 int res1 = 0 ;
43272 PyObject *swig_obj[1] ;
43273
43274 if (!args) SWIG_fail;
43275 swig_obj[0] = args;
43276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43277 if (!SWIG_IsOK(res1)) {
43278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43279 }
43280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43281 {
43282 PyThreadState* __tstate = wxPyBeginAllowThreads();
43283 {
43284 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43285 result = (wxBitmap *) &_result_ref;
43286 }
43287 wxPyEndAllowThreads(__tstate);
43288 if (PyErr_Occurred()) SWIG_fail;
43289 }
43290 {
43291 wxBitmap* resultptr = new wxBitmap(*result);
43292 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43293 }
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43301 PyObject *resultobj = 0;
43302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43303 wxFont *arg2 = 0 ;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 void *argp2 = 0 ;
43307 int res2 = 0 ;
43308 PyObject * obj0 = 0 ;
43309 PyObject * obj1 = 0 ;
43310 char * kwnames[] = {
43311 (char *) "self",(char *) "font", NULL
43312 };
43313
43314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43316 if (!SWIG_IsOK(res1)) {
43317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43318 }
43319 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43321 if (!SWIG_IsOK(res2)) {
43322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43323 }
43324 if (!argp2) {
43325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43326 }
43327 arg2 = reinterpret_cast< wxFont * >(argp2);
43328 {
43329 PyThreadState* __tstate = wxPyBeginAllowThreads();
43330 (arg1)->SetFont((wxFont const &)*arg2);
43331 wxPyEndAllowThreads(__tstate);
43332 if (PyErr_Occurred()) SWIG_fail;
43333 }
43334 resultobj = SWIG_Py_Void();
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43342 PyObject *resultobj = 0;
43343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43344 wxFont result;
43345 void *argp1 = 0 ;
43346 int res1 = 0 ;
43347 PyObject *swig_obj[1] ;
43348
43349 if (!args) SWIG_fail;
43350 swig_obj[0] = args;
43351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43352 if (!SWIG_IsOK(res1)) {
43353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43354 }
43355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 result = (arg1)->GetFont();
43359 wxPyEndAllowThreads(__tstate);
43360 if (PyErr_Occurred()) SWIG_fail;
43361 }
43362 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43363 return resultobj;
43364 fail:
43365 return NULL;
43366 }
43367
43368
43369 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43370 PyObject *resultobj = 0;
43371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43372 wxColour *arg2 = 0 ;
43373 void *argp1 = 0 ;
43374 int res1 = 0 ;
43375 wxColour temp2 ;
43376 PyObject * obj0 = 0 ;
43377 PyObject * obj1 = 0 ;
43378 char * kwnames[] = {
43379 (char *) "self",(char *) "colText", NULL
43380 };
43381
43382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43384 if (!SWIG_IsOK(res1)) {
43385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43386 }
43387 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43388 {
43389 arg2 = &temp2;
43390 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43391 }
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 (arg1)->SetTextColour((wxColour const &)*arg2);
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 resultobj = SWIG_Py_Void();
43399 return resultobj;
43400 fail:
43401 return NULL;
43402 }
43403
43404
43405 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43406 PyObject *resultobj = 0;
43407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43408 wxColour result;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 PyObject *swig_obj[1] ;
43412
43413 if (!args) SWIG_fail;
43414 swig_obj[0] = args;
43415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43416 if (!SWIG_IsOK(res1)) {
43417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43418 }
43419 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 result = (arg1)->GetTextColour();
43423 wxPyEndAllowThreads(__tstate);
43424 if (PyErr_Occurred()) SWIG_fail;
43425 }
43426 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43427 return resultobj;
43428 fail:
43429 return NULL;
43430 }
43431
43432
43433 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43434 PyObject *resultobj = 0;
43435 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43436 wxColour *arg2 = 0 ;
43437 void *argp1 = 0 ;
43438 int res1 = 0 ;
43439 wxColour temp2 ;
43440 PyObject * obj0 = 0 ;
43441 PyObject * obj1 = 0 ;
43442 char * kwnames[] = {
43443 (char *) "self",(char *) "colBack", NULL
43444 };
43445
43446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43448 if (!SWIG_IsOK(res1)) {
43449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43450 }
43451 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43452 {
43453 arg2 = &temp2;
43454 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43455 }
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43459 wxPyEndAllowThreads(__tstate);
43460 if (PyErr_Occurred()) SWIG_fail;
43461 }
43462 resultobj = SWIG_Py_Void();
43463 return resultobj;
43464 fail:
43465 return NULL;
43466 }
43467
43468
43469 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43470 PyObject *resultobj = 0;
43471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43472 wxColour result;
43473 void *argp1 = 0 ;
43474 int res1 = 0 ;
43475 PyObject *swig_obj[1] ;
43476
43477 if (!args) SWIG_fail;
43478 swig_obj[0] = args;
43479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res1)) {
43481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43482 }
43483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43484 {
43485 PyThreadState* __tstate = wxPyBeginAllowThreads();
43486 result = (arg1)->GetBackgroundColour();
43487 wxPyEndAllowThreads(__tstate);
43488 if (PyErr_Occurred()) SWIG_fail;
43489 }
43490 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43491 return resultobj;
43492 fail:
43493 return NULL;
43494 }
43495
43496
43497 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43498 PyObject *resultobj = 0;
43499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43500 wxBitmap *arg2 = 0 ;
43501 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43502 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43503 void *argp1 = 0 ;
43504 int res1 = 0 ;
43505 void *argp2 = 0 ;
43506 int res2 = 0 ;
43507 void *argp3 = 0 ;
43508 int res3 = 0 ;
43509 PyObject * obj0 = 0 ;
43510 PyObject * obj1 = 0 ;
43511 PyObject * obj2 = 0 ;
43512 char * kwnames[] = {
43513 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43514 };
43515
43516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43518 if (!SWIG_IsOK(res1)) {
43519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43520 }
43521 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43523 if (!SWIG_IsOK(res2)) {
43524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43525 }
43526 if (!argp2) {
43527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43528 }
43529 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43530 if (obj2) {
43531 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43532 if (!SWIG_IsOK(res3)) {
43533 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43534 }
43535 if (!argp3) {
43536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43537 }
43538 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43539 }
43540 {
43541 PyThreadState* __tstate = wxPyBeginAllowThreads();
43542 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 resultobj = SWIG_Py_Void();
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43554 PyObject *resultobj = 0;
43555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43556 wxBitmap *arg2 = 0 ;
43557 void *argp1 = 0 ;
43558 int res1 = 0 ;
43559 void *argp2 = 0 ;
43560 int res2 = 0 ;
43561 PyObject * obj0 = 0 ;
43562 PyObject * obj1 = 0 ;
43563 char * kwnames[] = {
43564 (char *) "self",(char *) "bmpDisabled", NULL
43565 };
43566
43567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43569 if (!SWIG_IsOK(res1)) {
43570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43571 }
43572 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43573 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43574 if (!SWIG_IsOK(res2)) {
43575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43576 }
43577 if (!argp2) {
43578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43579 }
43580 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43584 wxPyEndAllowThreads(__tstate);
43585 if (PyErr_Occurred()) SWIG_fail;
43586 }
43587 resultobj = SWIG_Py_Void();
43588 return resultobj;
43589 fail:
43590 return NULL;
43591 }
43592
43593
43594 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43595 PyObject *resultobj = 0;
43596 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43597 wxBitmap *result = 0 ;
43598 void *argp1 = 0 ;
43599 int res1 = 0 ;
43600 PyObject *swig_obj[1] ;
43601
43602 if (!args) SWIG_fail;
43603 swig_obj[0] = args;
43604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43605 if (!SWIG_IsOK(res1)) {
43606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43607 }
43608 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43609 {
43610 PyThreadState* __tstate = wxPyBeginAllowThreads();
43611 {
43612 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43613 result = (wxBitmap *) &_result_ref;
43614 }
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 {
43619 wxBitmap* resultptr = new wxBitmap(*result);
43620 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43621 }
43622 return resultobj;
43623 fail:
43624 return NULL;
43625 }
43626
43627
43628 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43629 PyObject *resultobj = 0;
43630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43631 int arg2 ;
43632 void *argp1 = 0 ;
43633 int res1 = 0 ;
43634 int val2 ;
43635 int ecode2 = 0 ;
43636 PyObject * obj0 = 0 ;
43637 PyObject * obj1 = 0 ;
43638 char * kwnames[] = {
43639 (char *) "self",(char *) "nWidth", NULL
43640 };
43641
43642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43644 if (!SWIG_IsOK(res1)) {
43645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43646 }
43647 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43648 ecode2 = SWIG_AsVal_int(obj1, &val2);
43649 if (!SWIG_IsOK(ecode2)) {
43650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43651 }
43652 arg2 = static_cast< int >(val2);
43653 {
43654 PyThreadState* __tstate = wxPyBeginAllowThreads();
43655 (arg1)->SetMarginWidth(arg2);
43656 wxPyEndAllowThreads(__tstate);
43657 if (PyErr_Occurred()) SWIG_fail;
43658 }
43659 resultobj = SWIG_Py_Void();
43660 return resultobj;
43661 fail:
43662 return NULL;
43663 }
43664
43665
43666 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43667 PyObject *resultobj = 0;
43668 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43669 int result;
43670 void *argp1 = 0 ;
43671 int res1 = 0 ;
43672 PyObject *swig_obj[1] ;
43673
43674 if (!args) SWIG_fail;
43675 swig_obj[0] = args;
43676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43677 if (!SWIG_IsOK(res1)) {
43678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43679 }
43680 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43681 {
43682 PyThreadState* __tstate = wxPyBeginAllowThreads();
43683 result = (int)(arg1)->GetMarginWidth();
43684 wxPyEndAllowThreads(__tstate);
43685 if (PyErr_Occurred()) SWIG_fail;
43686 }
43687 resultobj = SWIG_From_int(static_cast< int >(result));
43688 return resultobj;
43689 fail:
43690 return NULL;
43691 }
43692
43693
43694 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43695 PyObject *resultobj = 0;
43696 int result;
43697
43698 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43699 {
43700 PyThreadState* __tstate = wxPyBeginAllowThreads();
43701 result = (int)wxMenuItem::GetDefaultMarginWidth();
43702 wxPyEndAllowThreads(__tstate);
43703 if (PyErr_Occurred()) SWIG_fail;
43704 }
43705 resultobj = SWIG_From_int(static_cast< int >(result));
43706 return resultobj;
43707 fail:
43708 return NULL;
43709 }
43710
43711
43712 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43713 PyObject *resultobj = 0;
43714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43715 bool result;
43716 void *argp1 = 0 ;
43717 int res1 = 0 ;
43718 PyObject *swig_obj[1] ;
43719
43720 if (!args) SWIG_fail;
43721 swig_obj[0] = args;
43722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43723 if (!SWIG_IsOK(res1)) {
43724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43725 }
43726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43727 {
43728 PyThreadState* __tstate = wxPyBeginAllowThreads();
43729 result = (bool)(arg1)->IsOwnerDrawn();
43730 wxPyEndAllowThreads(__tstate);
43731 if (PyErr_Occurred()) SWIG_fail;
43732 }
43733 {
43734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43735 }
43736 return resultobj;
43737 fail:
43738 return NULL;
43739 }
43740
43741
43742 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43743 PyObject *resultobj = 0;
43744 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43745 bool arg2 = (bool) true ;
43746 void *argp1 = 0 ;
43747 int res1 = 0 ;
43748 bool val2 ;
43749 int ecode2 = 0 ;
43750 PyObject * obj0 = 0 ;
43751 PyObject * obj1 = 0 ;
43752 char * kwnames[] = {
43753 (char *) "self",(char *) "ownerDrawn", NULL
43754 };
43755
43756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43758 if (!SWIG_IsOK(res1)) {
43759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43760 }
43761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43762 if (obj1) {
43763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43764 if (!SWIG_IsOK(ecode2)) {
43765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43766 }
43767 arg2 = static_cast< bool >(val2);
43768 }
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 (arg1)->SetOwnerDrawn(arg2);
43772 wxPyEndAllowThreads(__tstate);
43773 if (PyErr_Occurred()) SWIG_fail;
43774 }
43775 resultobj = SWIG_Py_Void();
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43783 PyObject *resultobj = 0;
43784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43785 void *argp1 = 0 ;
43786 int res1 = 0 ;
43787 PyObject *swig_obj[1] ;
43788
43789 if (!args) SWIG_fail;
43790 swig_obj[0] = args;
43791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43792 if (!SWIG_IsOK(res1)) {
43793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43794 }
43795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43796 {
43797 PyThreadState* __tstate = wxPyBeginAllowThreads();
43798 (arg1)->ResetOwnerDrawn();
43799 wxPyEndAllowThreads(__tstate);
43800 if (PyErr_Occurred()) SWIG_fail;
43801 }
43802 resultobj = SWIG_Py_Void();
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43810 PyObject *obj;
43811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43812 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43813 return SWIG_Py_Void();
43814 }
43815
43816 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43817 return SWIG_Python_InitShadowInstance(args);
43818 }
43819
43820 SWIGINTERN int ControlNameStr_set(PyObject *) {
43821 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43822 return 1;
43823 }
43824
43825
43826 SWIGINTERN PyObject *ControlNameStr_get(void) {
43827 PyObject *pyobj = 0;
43828
43829 {
43830 #if wxUSE_UNICODE
43831 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43832 #else
43833 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43834 #endif
43835 }
43836 return pyobj;
43837 }
43838
43839
43840 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43841 PyObject *resultobj = 0;
43842 wxWindow *arg1 = (wxWindow *) 0 ;
43843 int arg2 = (int) -1 ;
43844 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43845 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43846 wxSize const &arg4_defvalue = wxDefaultSize ;
43847 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43848 long arg5 = (long) 0 ;
43849 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43850 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43851 wxString const &arg7_defvalue = wxPyControlNameStr ;
43852 wxString *arg7 = (wxString *) &arg7_defvalue ;
43853 wxControl *result = 0 ;
43854 void *argp1 = 0 ;
43855 int res1 = 0 ;
43856 int val2 ;
43857 int ecode2 = 0 ;
43858 wxPoint temp3 ;
43859 wxSize temp4 ;
43860 long val5 ;
43861 int ecode5 = 0 ;
43862 void *argp6 = 0 ;
43863 int res6 = 0 ;
43864 bool temp7 = false ;
43865 PyObject * obj0 = 0 ;
43866 PyObject * obj1 = 0 ;
43867 PyObject * obj2 = 0 ;
43868 PyObject * obj3 = 0 ;
43869 PyObject * obj4 = 0 ;
43870 PyObject * obj5 = 0 ;
43871 PyObject * obj6 = 0 ;
43872 char * kwnames[] = {
43873 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43874 };
43875
43876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43880 }
43881 arg1 = reinterpret_cast< wxWindow * >(argp1);
43882 if (obj1) {
43883 ecode2 = SWIG_AsVal_int(obj1, &val2);
43884 if (!SWIG_IsOK(ecode2)) {
43885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43886 }
43887 arg2 = static_cast< int >(val2);
43888 }
43889 if (obj2) {
43890 {
43891 arg3 = &temp3;
43892 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43893 }
43894 }
43895 if (obj3) {
43896 {
43897 arg4 = &temp4;
43898 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43899 }
43900 }
43901 if (obj4) {
43902 ecode5 = SWIG_AsVal_long(obj4, &val5);
43903 if (!SWIG_IsOK(ecode5)) {
43904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43905 }
43906 arg5 = static_cast< long >(val5);
43907 }
43908 if (obj5) {
43909 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43910 if (!SWIG_IsOK(res6)) {
43911 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43912 }
43913 if (!argp6) {
43914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43915 }
43916 arg6 = reinterpret_cast< wxValidator * >(argp6);
43917 }
43918 if (obj6) {
43919 {
43920 arg7 = wxString_in_helper(obj6);
43921 if (arg7 == NULL) SWIG_fail;
43922 temp7 = true;
43923 }
43924 }
43925 {
43926 if (!wxPyCheckForApp()) SWIG_fail;
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43933 {
43934 if (temp7)
43935 delete arg7;
43936 }
43937 return resultobj;
43938 fail:
43939 {
43940 if (temp7)
43941 delete arg7;
43942 }
43943 return NULL;
43944 }
43945
43946
43947 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43948 PyObject *resultobj = 0;
43949 wxControl *result = 0 ;
43950
43951 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43952 {
43953 if (!wxPyCheckForApp()) SWIG_fail;
43954 PyThreadState* __tstate = wxPyBeginAllowThreads();
43955 result = (wxControl *)new wxControl();
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43960 return resultobj;
43961 fail:
43962 return NULL;
43963 }
43964
43965
43966 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43967 PyObject *resultobj = 0;
43968 wxControl *arg1 = (wxControl *) 0 ;
43969 wxWindow *arg2 = (wxWindow *) 0 ;
43970 int arg3 = (int) -1 ;
43971 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43972 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43973 wxSize const &arg5_defvalue = wxDefaultSize ;
43974 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43975 long arg6 = (long) 0 ;
43976 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43977 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43978 wxString const &arg8_defvalue = wxPyControlNameStr ;
43979 wxString *arg8 = (wxString *) &arg8_defvalue ;
43980 bool result;
43981 void *argp1 = 0 ;
43982 int res1 = 0 ;
43983 void *argp2 = 0 ;
43984 int res2 = 0 ;
43985 int val3 ;
43986 int ecode3 = 0 ;
43987 wxPoint temp4 ;
43988 wxSize temp5 ;
43989 long val6 ;
43990 int ecode6 = 0 ;
43991 void *argp7 = 0 ;
43992 int res7 = 0 ;
43993 bool temp8 = false ;
43994 PyObject * obj0 = 0 ;
43995 PyObject * obj1 = 0 ;
43996 PyObject * obj2 = 0 ;
43997 PyObject * obj3 = 0 ;
43998 PyObject * obj4 = 0 ;
43999 PyObject * obj5 = 0 ;
44000 PyObject * obj6 = 0 ;
44001 PyObject * obj7 = 0 ;
44002 char * kwnames[] = {
44003 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44004 };
44005
44006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44008 if (!SWIG_IsOK(res1)) {
44009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44010 }
44011 arg1 = reinterpret_cast< wxControl * >(argp1);
44012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44013 if (!SWIG_IsOK(res2)) {
44014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44015 }
44016 arg2 = reinterpret_cast< wxWindow * >(argp2);
44017 if (obj2) {
44018 ecode3 = SWIG_AsVal_int(obj2, &val3);
44019 if (!SWIG_IsOK(ecode3)) {
44020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44021 }
44022 arg3 = static_cast< int >(val3);
44023 }
44024 if (obj3) {
44025 {
44026 arg4 = &temp4;
44027 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44028 }
44029 }
44030 if (obj4) {
44031 {
44032 arg5 = &temp5;
44033 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44034 }
44035 }
44036 if (obj5) {
44037 ecode6 = SWIG_AsVal_long(obj5, &val6);
44038 if (!SWIG_IsOK(ecode6)) {
44039 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44040 }
44041 arg6 = static_cast< long >(val6);
44042 }
44043 if (obj6) {
44044 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44045 if (!SWIG_IsOK(res7)) {
44046 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44047 }
44048 if (!argp7) {
44049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44050 }
44051 arg7 = reinterpret_cast< wxValidator * >(argp7);
44052 }
44053 if (obj7) {
44054 {
44055 arg8 = wxString_in_helper(obj7);
44056 if (arg8 == NULL) SWIG_fail;
44057 temp8 = true;
44058 }
44059 }
44060 {
44061 PyThreadState* __tstate = wxPyBeginAllowThreads();
44062 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44063 wxPyEndAllowThreads(__tstate);
44064 if (PyErr_Occurred()) SWIG_fail;
44065 }
44066 {
44067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44068 }
44069 {
44070 if (temp8)
44071 delete arg8;
44072 }
44073 return resultobj;
44074 fail:
44075 {
44076 if (temp8)
44077 delete arg8;
44078 }
44079 return NULL;
44080 }
44081
44082
44083 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44084 PyObject *resultobj = 0;
44085 wxControl *arg1 = (wxControl *) 0 ;
44086 wxCommandEvent *arg2 = 0 ;
44087 void *argp1 = 0 ;
44088 int res1 = 0 ;
44089 void *argp2 = 0 ;
44090 int res2 = 0 ;
44091 PyObject * obj0 = 0 ;
44092 PyObject * obj1 = 0 ;
44093 char * kwnames[] = {
44094 (char *) "self",(char *) "event", NULL
44095 };
44096
44097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44099 if (!SWIG_IsOK(res1)) {
44100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44101 }
44102 arg1 = reinterpret_cast< wxControl * >(argp1);
44103 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44104 if (!SWIG_IsOK(res2)) {
44105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44106 }
44107 if (!argp2) {
44108 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44109 }
44110 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44111 {
44112 PyThreadState* __tstate = wxPyBeginAllowThreads();
44113 (arg1)->Command(*arg2);
44114 wxPyEndAllowThreads(__tstate);
44115 if (PyErr_Occurred()) SWIG_fail;
44116 }
44117 resultobj = SWIG_Py_Void();
44118 return resultobj;
44119 fail:
44120 return NULL;
44121 }
44122
44123
44124 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44125 PyObject *resultobj = 0;
44126 wxControl *arg1 = (wxControl *) 0 ;
44127 wxString result;
44128 void *argp1 = 0 ;
44129 int res1 = 0 ;
44130 PyObject *swig_obj[1] ;
44131
44132 if (!args) SWIG_fail;
44133 swig_obj[0] = args;
44134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44135 if (!SWIG_IsOK(res1)) {
44136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44137 }
44138 arg1 = reinterpret_cast< wxControl * >(argp1);
44139 {
44140 PyThreadState* __tstate = wxPyBeginAllowThreads();
44141 result = (arg1)->GetLabel();
44142 wxPyEndAllowThreads(__tstate);
44143 if (PyErr_Occurred()) SWIG_fail;
44144 }
44145 {
44146 #if wxUSE_UNICODE
44147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44148 #else
44149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44150 #endif
44151 }
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44159 PyObject *resultobj = 0;
44160 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44161 SwigValueWrapper<wxVisualAttributes > result;
44162 int val1 ;
44163 int ecode1 = 0 ;
44164 PyObject * obj0 = 0 ;
44165 char * kwnames[] = {
44166 (char *) "variant", NULL
44167 };
44168
44169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44170 if (obj0) {
44171 ecode1 = SWIG_AsVal_int(obj0, &val1);
44172 if (!SWIG_IsOK(ecode1)) {
44173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44174 }
44175 arg1 = static_cast< wxWindowVariant >(val1);
44176 }
44177 {
44178 if (!wxPyCheckForApp()) SWIG_fail;
44179 PyThreadState* __tstate = wxPyBeginAllowThreads();
44180 result = wxControl::GetClassDefaultAttributes(arg1);
44181 wxPyEndAllowThreads(__tstate);
44182 if (PyErr_Occurred()) SWIG_fail;
44183 }
44184 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44185 return resultobj;
44186 fail:
44187 return NULL;
44188 }
44189
44190
44191 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44192 PyObject *obj;
44193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44194 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44195 return SWIG_Py_Void();
44196 }
44197
44198 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44199 return SWIG_Python_InitShadowInstance(args);
44200 }
44201
44202 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44203 PyObject *resultobj = 0;
44204 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44205 wxString *arg2 = 0 ;
44206 PyObject *arg3 = (PyObject *) NULL ;
44207 int result;
44208 void *argp1 = 0 ;
44209 int res1 = 0 ;
44210 bool temp2 = false ;
44211 PyObject * obj0 = 0 ;
44212 PyObject * obj1 = 0 ;
44213 PyObject * obj2 = 0 ;
44214 char * kwnames[] = {
44215 (char *) "self",(char *) "item",(char *) "clientData", NULL
44216 };
44217
44218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44220 if (!SWIG_IsOK(res1)) {
44221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44222 }
44223 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44224 {
44225 arg2 = wxString_in_helper(obj1);
44226 if (arg2 == NULL) SWIG_fail;
44227 temp2 = true;
44228 }
44229 if (obj2) {
44230 arg3 = obj2;
44231 }
44232 {
44233 PyThreadState* __tstate = wxPyBeginAllowThreads();
44234 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44235 wxPyEndAllowThreads(__tstate);
44236 if (PyErr_Occurred()) SWIG_fail;
44237 }
44238 resultobj = SWIG_From_int(static_cast< int >(result));
44239 {
44240 if (temp2)
44241 delete arg2;
44242 }
44243 return resultobj;
44244 fail:
44245 {
44246 if (temp2)
44247 delete arg2;
44248 }
44249 return NULL;
44250 }
44251
44252
44253 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44254 PyObject *resultobj = 0;
44255 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44256 wxArrayString *arg2 = 0 ;
44257 void *argp1 = 0 ;
44258 int res1 = 0 ;
44259 bool temp2 = false ;
44260 PyObject * obj0 = 0 ;
44261 PyObject * obj1 = 0 ;
44262 char * kwnames[] = {
44263 (char *) "self",(char *) "strings", NULL
44264 };
44265
44266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44268 if (!SWIG_IsOK(res1)) {
44269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44270 }
44271 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44272 {
44273 if (! PySequence_Check(obj1)) {
44274 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44275 SWIG_fail;
44276 }
44277 arg2 = new wxArrayString;
44278 temp2 = true;
44279 int i, len=PySequence_Length(obj1);
44280 for (i=0; i<len; i++) {
44281 PyObject* item = PySequence_GetItem(obj1, i);
44282 wxString* s = wxString_in_helper(item);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 arg2->Add(*s);
44285 delete s;
44286 Py_DECREF(item);
44287 }
44288 }
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 (arg1)->Append((wxArrayString const &)*arg2);
44292 wxPyEndAllowThreads(__tstate);
44293 if (PyErr_Occurred()) SWIG_fail;
44294 }
44295 resultobj = SWIG_Py_Void();
44296 {
44297 if (temp2) delete arg2;
44298 }
44299 return resultobj;
44300 fail:
44301 {
44302 if (temp2) delete arg2;
44303 }
44304 return NULL;
44305 }
44306
44307
44308 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44309 PyObject *resultobj = 0;
44310 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44311 wxString *arg2 = 0 ;
44312 unsigned int arg3 ;
44313 PyObject *arg4 = (PyObject *) NULL ;
44314 int result;
44315 void *argp1 = 0 ;
44316 int res1 = 0 ;
44317 bool temp2 = false ;
44318 unsigned int val3 ;
44319 int ecode3 = 0 ;
44320 PyObject * obj0 = 0 ;
44321 PyObject * obj1 = 0 ;
44322 PyObject * obj2 = 0 ;
44323 PyObject * obj3 = 0 ;
44324 char * kwnames[] = {
44325 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44326 };
44327
44328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44330 if (!SWIG_IsOK(res1)) {
44331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44332 }
44333 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44334 {
44335 arg2 = wxString_in_helper(obj1);
44336 if (arg2 == NULL) SWIG_fail;
44337 temp2 = true;
44338 }
44339 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44340 if (!SWIG_IsOK(ecode3)) {
44341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44342 }
44343 arg3 = static_cast< unsigned int >(val3);
44344 if (obj3) {
44345 arg4 = obj3;
44346 }
44347 {
44348 PyThreadState* __tstate = wxPyBeginAllowThreads();
44349 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44350 wxPyEndAllowThreads(__tstate);
44351 if (PyErr_Occurred()) SWIG_fail;
44352 }
44353 resultobj = SWIG_From_int(static_cast< int >(result));
44354 {
44355 if (temp2)
44356 delete arg2;
44357 }
44358 return resultobj;
44359 fail:
44360 {
44361 if (temp2)
44362 delete arg2;
44363 }
44364 return NULL;
44365 }
44366
44367
44368 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44369 PyObject *resultobj = 0;
44370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44371 void *argp1 = 0 ;
44372 int res1 = 0 ;
44373 PyObject *swig_obj[1] ;
44374
44375 if (!args) SWIG_fail;
44376 swig_obj[0] = args;
44377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44378 if (!SWIG_IsOK(res1)) {
44379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44380 }
44381 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44382 {
44383 PyThreadState* __tstate = wxPyBeginAllowThreads();
44384 (arg1)->Clear();
44385 wxPyEndAllowThreads(__tstate);
44386 if (PyErr_Occurred()) SWIG_fail;
44387 }
44388 resultobj = SWIG_Py_Void();
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44396 PyObject *resultobj = 0;
44397 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44398 unsigned int arg2 ;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 unsigned int val2 ;
44402 int ecode2 = 0 ;
44403 PyObject * obj0 = 0 ;
44404 PyObject * obj1 = 0 ;
44405 char * kwnames[] = {
44406 (char *) "self",(char *) "n", NULL
44407 };
44408
44409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44411 if (!SWIG_IsOK(res1)) {
44412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44413 }
44414 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44415 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44416 if (!SWIG_IsOK(ecode2)) {
44417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44418 }
44419 arg2 = static_cast< unsigned int >(val2);
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->Delete(arg2);
44423 wxPyEndAllowThreads(__tstate);
44424 if (PyErr_Occurred()) SWIG_fail;
44425 }
44426 resultobj = SWIG_Py_Void();
44427 return resultobj;
44428 fail:
44429 return NULL;
44430 }
44431
44432
44433 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44434 PyObject *resultobj = 0;
44435 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44436 unsigned int arg2 ;
44437 PyObject *result = 0 ;
44438 void *argp1 = 0 ;
44439 int res1 = 0 ;
44440 unsigned int val2 ;
44441 int ecode2 = 0 ;
44442 PyObject * obj0 = 0 ;
44443 PyObject * obj1 = 0 ;
44444 char * kwnames[] = {
44445 (char *) "self",(char *) "n", NULL
44446 };
44447
44448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44450 if (!SWIG_IsOK(res1)) {
44451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44452 }
44453 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44454 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44455 if (!SWIG_IsOK(ecode2)) {
44456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44457 }
44458 arg2 = static_cast< unsigned int >(val2);
44459 {
44460 PyThreadState* __tstate = wxPyBeginAllowThreads();
44461 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44462 wxPyEndAllowThreads(__tstate);
44463 if (PyErr_Occurred()) SWIG_fail;
44464 }
44465 resultobj = result;
44466 return resultobj;
44467 fail:
44468 return NULL;
44469 }
44470
44471
44472 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44473 PyObject *resultobj = 0;
44474 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44475 unsigned int arg2 ;
44476 PyObject *arg3 = (PyObject *) 0 ;
44477 void *argp1 = 0 ;
44478 int res1 = 0 ;
44479 unsigned int val2 ;
44480 int ecode2 = 0 ;
44481 PyObject * obj0 = 0 ;
44482 PyObject * obj1 = 0 ;
44483 PyObject * obj2 = 0 ;
44484 char * kwnames[] = {
44485 (char *) "self",(char *) "n",(char *) "clientData", NULL
44486 };
44487
44488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44490 if (!SWIG_IsOK(res1)) {
44491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44492 }
44493 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44494 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44495 if (!SWIG_IsOK(ecode2)) {
44496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44497 }
44498 arg2 = static_cast< unsigned int >(val2);
44499 arg3 = obj2;
44500 {
44501 PyThreadState* __tstate = wxPyBeginAllowThreads();
44502 wxItemContainer_SetClientData(arg1,arg2,arg3);
44503 wxPyEndAllowThreads(__tstate);
44504 if (PyErr_Occurred()) SWIG_fail;
44505 }
44506 resultobj = SWIG_Py_Void();
44507 return resultobj;
44508 fail:
44509 return NULL;
44510 }
44511
44512
44513 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44514 PyObject *resultobj = 0;
44515 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44516 unsigned int result;
44517 void *argp1 = 0 ;
44518 int res1 = 0 ;
44519 PyObject *swig_obj[1] ;
44520
44521 if (!args) SWIG_fail;
44522 swig_obj[0] = args;
44523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44526 }
44527 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44535 return resultobj;
44536 fail:
44537 return NULL;
44538 }
44539
44540
44541 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44542 PyObject *resultobj = 0;
44543 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44544 bool result;
44545 void *argp1 = 0 ;
44546 int res1 = 0 ;
44547 PyObject *swig_obj[1] ;
44548
44549 if (!args) SWIG_fail;
44550 swig_obj[0] = args;
44551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44552 if (!SWIG_IsOK(res1)) {
44553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44554 }
44555 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44556 {
44557 PyThreadState* __tstate = wxPyBeginAllowThreads();
44558 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44559 wxPyEndAllowThreads(__tstate);
44560 if (PyErr_Occurred()) SWIG_fail;
44561 }
44562 {
44563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44564 }
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj = 0;
44573 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44574 unsigned int arg2 ;
44575 wxString result;
44576 void *argp1 = 0 ;
44577 int res1 = 0 ;
44578 unsigned int val2 ;
44579 int ecode2 = 0 ;
44580 PyObject * obj0 = 0 ;
44581 PyObject * obj1 = 0 ;
44582 char * kwnames[] = {
44583 (char *) "self",(char *) "n", NULL
44584 };
44585
44586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44588 if (!SWIG_IsOK(res1)) {
44589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44590 }
44591 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44592 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44593 if (!SWIG_IsOK(ecode2)) {
44594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44595 }
44596 arg2 = static_cast< unsigned int >(val2);
44597 {
44598 PyThreadState* __tstate = wxPyBeginAllowThreads();
44599 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44600 wxPyEndAllowThreads(__tstate);
44601 if (PyErr_Occurred()) SWIG_fail;
44602 }
44603 {
44604 #if wxUSE_UNICODE
44605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44606 #else
44607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44608 #endif
44609 }
44610 return resultobj;
44611 fail:
44612 return NULL;
44613 }
44614
44615
44616 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44617 PyObject *resultobj = 0;
44618 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44619 wxArrayString result;
44620 void *argp1 = 0 ;
44621 int res1 = 0 ;
44622 PyObject *swig_obj[1] ;
44623
44624 if (!args) SWIG_fail;
44625 swig_obj[0] = args;
44626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44627 if (!SWIG_IsOK(res1)) {
44628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44629 }
44630 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44631 {
44632 PyThreadState* __tstate = wxPyBeginAllowThreads();
44633 result = ((wxItemContainer const *)arg1)->GetStrings();
44634 wxPyEndAllowThreads(__tstate);
44635 if (PyErr_Occurred()) SWIG_fail;
44636 }
44637 {
44638 resultobj = wxArrayString2PyList_helper(result);
44639 }
44640 return resultobj;
44641 fail:
44642 return NULL;
44643 }
44644
44645
44646 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44647 PyObject *resultobj = 0;
44648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44649 unsigned int arg2 ;
44650 wxString *arg3 = 0 ;
44651 void *argp1 = 0 ;
44652 int res1 = 0 ;
44653 unsigned int val2 ;
44654 int ecode2 = 0 ;
44655 bool temp3 = false ;
44656 PyObject * obj0 = 0 ;
44657 PyObject * obj1 = 0 ;
44658 PyObject * obj2 = 0 ;
44659 char * kwnames[] = {
44660 (char *) "self",(char *) "n",(char *) "s", NULL
44661 };
44662
44663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44665 if (!SWIG_IsOK(res1)) {
44666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44667 }
44668 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44669 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44670 if (!SWIG_IsOK(ecode2)) {
44671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44672 }
44673 arg2 = static_cast< unsigned int >(val2);
44674 {
44675 arg3 = wxString_in_helper(obj2);
44676 if (arg3 == NULL) SWIG_fail;
44677 temp3 = true;
44678 }
44679 {
44680 PyThreadState* __tstate = wxPyBeginAllowThreads();
44681 (arg1)->SetString(arg2,(wxString const &)*arg3);
44682 wxPyEndAllowThreads(__tstate);
44683 if (PyErr_Occurred()) SWIG_fail;
44684 }
44685 resultobj = SWIG_Py_Void();
44686 {
44687 if (temp3)
44688 delete arg3;
44689 }
44690 return resultobj;
44691 fail:
44692 {
44693 if (temp3)
44694 delete arg3;
44695 }
44696 return NULL;
44697 }
44698
44699
44700 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44701 PyObject *resultobj = 0;
44702 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44703 wxString *arg2 = 0 ;
44704 int result;
44705 void *argp1 = 0 ;
44706 int res1 = 0 ;
44707 bool temp2 = false ;
44708 PyObject * obj0 = 0 ;
44709 PyObject * obj1 = 0 ;
44710 char * kwnames[] = {
44711 (char *) "self",(char *) "s", NULL
44712 };
44713
44714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44716 if (!SWIG_IsOK(res1)) {
44717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44718 }
44719 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44720 {
44721 arg2 = wxString_in_helper(obj1);
44722 if (arg2 == NULL) SWIG_fail;
44723 temp2 = true;
44724 }
44725 {
44726 PyThreadState* __tstate = wxPyBeginAllowThreads();
44727 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44728 wxPyEndAllowThreads(__tstate);
44729 if (PyErr_Occurred()) SWIG_fail;
44730 }
44731 resultobj = SWIG_From_int(static_cast< int >(result));
44732 {
44733 if (temp2)
44734 delete arg2;
44735 }
44736 return resultobj;
44737 fail:
44738 {
44739 if (temp2)
44740 delete arg2;
44741 }
44742 return NULL;
44743 }
44744
44745
44746 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44747 PyObject *resultobj = 0;
44748 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44749 int arg2 ;
44750 void *argp1 = 0 ;
44751 int res1 = 0 ;
44752 int val2 ;
44753 int ecode2 = 0 ;
44754 PyObject * obj0 = 0 ;
44755 PyObject * obj1 = 0 ;
44756 char * kwnames[] = {
44757 (char *) "self",(char *) "n", NULL
44758 };
44759
44760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44762 if (!SWIG_IsOK(res1)) {
44763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44764 }
44765 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44766 ecode2 = SWIG_AsVal_int(obj1, &val2);
44767 if (!SWIG_IsOK(ecode2)) {
44768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44769 }
44770 arg2 = static_cast< int >(val2);
44771 {
44772 PyThreadState* __tstate = wxPyBeginAllowThreads();
44773 (arg1)->SetSelection(arg2);
44774 wxPyEndAllowThreads(__tstate);
44775 if (PyErr_Occurred()) SWIG_fail;
44776 }
44777 resultobj = SWIG_Py_Void();
44778 return resultobj;
44779 fail:
44780 return NULL;
44781 }
44782
44783
44784 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44785 PyObject *resultobj = 0;
44786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44787 int result;
44788 void *argp1 = 0 ;
44789 int res1 = 0 ;
44790 PyObject *swig_obj[1] ;
44791
44792 if (!args) SWIG_fail;
44793 swig_obj[0] = args;
44794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44795 if (!SWIG_IsOK(res1)) {
44796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44797 }
44798 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44799 {
44800 PyThreadState* __tstate = wxPyBeginAllowThreads();
44801 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44802 wxPyEndAllowThreads(__tstate);
44803 if (PyErr_Occurred()) SWIG_fail;
44804 }
44805 resultobj = SWIG_From_int(static_cast< int >(result));
44806 return resultobj;
44807 fail:
44808 return NULL;
44809 }
44810
44811
44812 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44813 PyObject *resultobj = 0;
44814 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44815 wxString *arg2 = 0 ;
44816 bool result;
44817 void *argp1 = 0 ;
44818 int res1 = 0 ;
44819 bool temp2 = false ;
44820 PyObject * obj0 = 0 ;
44821 PyObject * obj1 = 0 ;
44822 char * kwnames[] = {
44823 (char *) "self",(char *) "s", NULL
44824 };
44825
44826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44828 if (!SWIG_IsOK(res1)) {
44829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44830 }
44831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44832 {
44833 arg2 = wxString_in_helper(obj1);
44834 if (arg2 == NULL) SWIG_fail;
44835 temp2 = true;
44836 }
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 {
44844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44845 }
44846 {
44847 if (temp2)
44848 delete arg2;
44849 }
44850 return resultobj;
44851 fail:
44852 {
44853 if (temp2)
44854 delete arg2;
44855 }
44856 return NULL;
44857 }
44858
44859
44860 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44861 PyObject *resultobj = 0;
44862 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44863 wxString result;
44864 void *argp1 = 0 ;
44865 int res1 = 0 ;
44866 PyObject *swig_obj[1] ;
44867
44868 if (!args) SWIG_fail;
44869 swig_obj[0] = args;
44870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44871 if (!SWIG_IsOK(res1)) {
44872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44873 }
44874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44875 {
44876 PyThreadState* __tstate = wxPyBeginAllowThreads();
44877 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44878 wxPyEndAllowThreads(__tstate);
44879 if (PyErr_Occurred()) SWIG_fail;
44880 }
44881 {
44882 #if wxUSE_UNICODE
44883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44884 #else
44885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44886 #endif
44887 }
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44895 PyObject *resultobj = 0;
44896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44897 int arg2 ;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 int val2 ;
44901 int ecode2 = 0 ;
44902 PyObject * obj0 = 0 ;
44903 PyObject * obj1 = 0 ;
44904 char * kwnames[] = {
44905 (char *) "self",(char *) "n", NULL
44906 };
44907
44908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44910 if (!SWIG_IsOK(res1)) {
44911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44912 }
44913 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44914 ecode2 = SWIG_AsVal_int(obj1, &val2);
44915 if (!SWIG_IsOK(ecode2)) {
44916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44917 }
44918 arg2 = static_cast< int >(val2);
44919 {
44920 PyThreadState* __tstate = wxPyBeginAllowThreads();
44921 (arg1)->Select(arg2);
44922 wxPyEndAllowThreads(__tstate);
44923 if (PyErr_Occurred()) SWIG_fail;
44924 }
44925 resultobj = SWIG_Py_Void();
44926 return resultobj;
44927 fail:
44928 return NULL;
44929 }
44930
44931
44932 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44933 PyObject *obj;
44934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44935 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44936 return SWIG_Py_Void();
44937 }
44938
44939 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44940 PyObject *obj;
44941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44942 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44943 return SWIG_Py_Void();
44944 }
44945
44946 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44947 PyObject *resultobj = 0;
44948 wxSizerItem *result = 0 ;
44949
44950 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44951 {
44952 PyThreadState* __tstate = wxPyBeginAllowThreads();
44953 result = (wxSizerItem *)new wxSizerItem();
44954 wxPyEndAllowThreads(__tstate);
44955 if (PyErr_Occurred()) SWIG_fail;
44956 }
44957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44958 return resultobj;
44959 fail:
44960 return NULL;
44961 }
44962
44963
44964 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44965 PyObject *resultobj = 0;
44966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 PyObject *swig_obj[1] ;
44970
44971 if (!args) SWIG_fail;
44972 swig_obj[0] = args;
44973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44976 }
44977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44978 {
44979 PyThreadState* __tstate = wxPyBeginAllowThreads();
44980 delete arg1;
44981
44982 wxPyEndAllowThreads(__tstate);
44983 if (PyErr_Occurred()) SWIG_fail;
44984 }
44985 resultobj = SWIG_Py_Void();
44986 return resultobj;
44987 fail:
44988 return NULL;
44989 }
44990
44991
44992 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj = 0;
44994 wxWindow *arg1 = (wxWindow *) 0 ;
44995 int arg2 ;
44996 int arg3 ;
44997 int arg4 ;
44998 PyObject *arg5 = (PyObject *) NULL ;
44999 wxSizerItem *result = 0 ;
45000 void *argp1 = 0 ;
45001 int res1 = 0 ;
45002 int val2 ;
45003 int ecode2 = 0 ;
45004 int val3 ;
45005 int ecode3 = 0 ;
45006 int val4 ;
45007 int ecode4 = 0 ;
45008 PyObject * obj0 = 0 ;
45009 PyObject * obj1 = 0 ;
45010 PyObject * obj2 = 0 ;
45011 PyObject * obj3 = 0 ;
45012 PyObject * obj4 = 0 ;
45013 char * kwnames[] = {
45014 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45015 };
45016
45017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45019 if (!SWIG_IsOK(res1)) {
45020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45021 }
45022 arg1 = reinterpret_cast< wxWindow * >(argp1);
45023 ecode2 = SWIG_AsVal_int(obj1, &val2);
45024 if (!SWIG_IsOK(ecode2)) {
45025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45026 }
45027 arg2 = static_cast< int >(val2);
45028 ecode3 = SWIG_AsVal_int(obj2, &val3);
45029 if (!SWIG_IsOK(ecode3)) {
45030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45031 }
45032 arg3 = static_cast< int >(val3);
45033 ecode4 = SWIG_AsVal_int(obj3, &val4);
45034 if (!SWIG_IsOK(ecode4)) {
45035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45036 }
45037 arg4 = static_cast< int >(val4);
45038 if (obj4) {
45039 arg5 = obj4;
45040 }
45041 {
45042 PyThreadState* __tstate = wxPyBeginAllowThreads();
45043 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45044 wxPyEndAllowThreads(__tstate);
45045 if (PyErr_Occurred()) SWIG_fail;
45046 }
45047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45048 return resultobj;
45049 fail:
45050 return NULL;
45051 }
45052
45053
45054 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45055 PyObject *resultobj = 0;
45056 int arg1 ;
45057 int arg2 ;
45058 int arg3 ;
45059 int arg4 ;
45060 int arg5 ;
45061 PyObject *arg6 = (PyObject *) NULL ;
45062 wxSizerItem *result = 0 ;
45063 int val1 ;
45064 int ecode1 = 0 ;
45065 int val2 ;
45066 int ecode2 = 0 ;
45067 int val3 ;
45068 int ecode3 = 0 ;
45069 int val4 ;
45070 int ecode4 = 0 ;
45071 int val5 ;
45072 int ecode5 = 0 ;
45073 PyObject * obj0 = 0 ;
45074 PyObject * obj1 = 0 ;
45075 PyObject * obj2 = 0 ;
45076 PyObject * obj3 = 0 ;
45077 PyObject * obj4 = 0 ;
45078 PyObject * obj5 = 0 ;
45079 char * kwnames[] = {
45080 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45081 };
45082
45083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45084 ecode1 = SWIG_AsVal_int(obj0, &val1);
45085 if (!SWIG_IsOK(ecode1)) {
45086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45087 }
45088 arg1 = static_cast< int >(val1);
45089 ecode2 = SWIG_AsVal_int(obj1, &val2);
45090 if (!SWIG_IsOK(ecode2)) {
45091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45092 }
45093 arg2 = static_cast< int >(val2);
45094 ecode3 = SWIG_AsVal_int(obj2, &val3);
45095 if (!SWIG_IsOK(ecode3)) {
45096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45097 }
45098 arg3 = static_cast< int >(val3);
45099 ecode4 = SWIG_AsVal_int(obj3, &val4);
45100 if (!SWIG_IsOK(ecode4)) {
45101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45102 }
45103 arg4 = static_cast< int >(val4);
45104 ecode5 = SWIG_AsVal_int(obj4, &val5);
45105 if (!SWIG_IsOK(ecode5)) {
45106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45107 }
45108 arg5 = static_cast< int >(val5);
45109 if (obj5) {
45110 arg6 = obj5;
45111 }
45112 {
45113 PyThreadState* __tstate = wxPyBeginAllowThreads();
45114 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj = 0;
45127 wxSizer *arg1 = (wxSizer *) 0 ;
45128 int arg2 ;
45129 int arg3 ;
45130 int arg4 ;
45131 PyObject *arg5 = (PyObject *) NULL ;
45132 wxSizerItem *result = 0 ;
45133 int res1 = 0 ;
45134 int val2 ;
45135 int ecode2 = 0 ;
45136 int val3 ;
45137 int ecode3 = 0 ;
45138 int val4 ;
45139 int ecode4 = 0 ;
45140 PyObject * obj0 = 0 ;
45141 PyObject * obj1 = 0 ;
45142 PyObject * obj2 = 0 ;
45143 PyObject * obj3 = 0 ;
45144 PyObject * obj4 = 0 ;
45145 char * kwnames[] = {
45146 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45147 };
45148
45149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45150 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45151 if (!SWIG_IsOK(res1)) {
45152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45153 }
45154 ecode2 = SWIG_AsVal_int(obj1, &val2);
45155 if (!SWIG_IsOK(ecode2)) {
45156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45157 }
45158 arg2 = static_cast< int >(val2);
45159 ecode3 = SWIG_AsVal_int(obj2, &val3);
45160 if (!SWIG_IsOK(ecode3)) {
45161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45162 }
45163 arg3 = static_cast< int >(val3);
45164 ecode4 = SWIG_AsVal_int(obj3, &val4);
45165 if (!SWIG_IsOK(ecode4)) {
45166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45167 }
45168 arg4 = static_cast< int >(val4);
45169 if (obj4) {
45170 arg5 = obj4;
45171 }
45172 {
45173 PyThreadState* __tstate = wxPyBeginAllowThreads();
45174 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45175 wxPyEndAllowThreads(__tstate);
45176 if (PyErr_Occurred()) SWIG_fail;
45177 }
45178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45179 return resultobj;
45180 fail:
45181 return NULL;
45182 }
45183
45184
45185 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45186 PyObject *resultobj = 0;
45187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45188 void *argp1 = 0 ;
45189 int res1 = 0 ;
45190 PyObject *swig_obj[1] ;
45191
45192 if (!args) SWIG_fail;
45193 swig_obj[0] = args;
45194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45195 if (!SWIG_IsOK(res1)) {
45196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45197 }
45198 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45199 {
45200 PyThreadState* __tstate = wxPyBeginAllowThreads();
45201 (arg1)->DeleteWindows();
45202 wxPyEndAllowThreads(__tstate);
45203 if (PyErr_Occurred()) SWIG_fail;
45204 }
45205 resultobj = SWIG_Py_Void();
45206 return resultobj;
45207 fail:
45208 return NULL;
45209 }
45210
45211
45212 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45213 PyObject *resultobj = 0;
45214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 PyObject *swig_obj[1] ;
45218
45219 if (!args) SWIG_fail;
45220 swig_obj[0] = args;
45221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45222 if (!SWIG_IsOK(res1)) {
45223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45224 }
45225 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45226 {
45227 PyThreadState* __tstate = wxPyBeginAllowThreads();
45228 (arg1)->DetachSizer();
45229 wxPyEndAllowThreads(__tstate);
45230 if (PyErr_Occurred()) SWIG_fail;
45231 }
45232 resultobj = SWIG_Py_Void();
45233 return resultobj;
45234 fail:
45235 return NULL;
45236 }
45237
45238
45239 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45240 PyObject *resultobj = 0;
45241 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45242 wxSize result;
45243 void *argp1 = 0 ;
45244 int res1 = 0 ;
45245 PyObject *swig_obj[1] ;
45246
45247 if (!args) SWIG_fail;
45248 swig_obj[0] = args;
45249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45252 }
45253 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45254 {
45255 PyThreadState* __tstate = wxPyBeginAllowThreads();
45256 result = (arg1)->GetSize();
45257 wxPyEndAllowThreads(__tstate);
45258 if (PyErr_Occurred()) SWIG_fail;
45259 }
45260 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45261 return resultobj;
45262 fail:
45263 return NULL;
45264 }
45265
45266
45267 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45268 PyObject *resultobj = 0;
45269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45270 wxSize result;
45271 void *argp1 = 0 ;
45272 int res1 = 0 ;
45273 PyObject *swig_obj[1] ;
45274
45275 if (!args) SWIG_fail;
45276 swig_obj[0] = args;
45277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45278 if (!SWIG_IsOK(res1)) {
45279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45280 }
45281 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45282 {
45283 PyThreadState* __tstate = wxPyBeginAllowThreads();
45284 result = (arg1)->CalcMin();
45285 wxPyEndAllowThreads(__tstate);
45286 if (PyErr_Occurred()) SWIG_fail;
45287 }
45288 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45289 return resultobj;
45290 fail:
45291 return NULL;
45292 }
45293
45294
45295 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45296 PyObject *resultobj = 0;
45297 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45298 wxPoint *arg2 = 0 ;
45299 wxSize *arg3 = 0 ;
45300 void *argp1 = 0 ;
45301 int res1 = 0 ;
45302 wxPoint temp2 ;
45303 wxSize temp3 ;
45304 PyObject * obj0 = 0 ;
45305 PyObject * obj1 = 0 ;
45306 PyObject * obj2 = 0 ;
45307 char * kwnames[] = {
45308 (char *) "self",(char *) "pos",(char *) "size", NULL
45309 };
45310
45311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45313 if (!SWIG_IsOK(res1)) {
45314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45315 }
45316 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45317 {
45318 arg2 = &temp2;
45319 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45320 }
45321 {
45322 arg3 = &temp3;
45323 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45324 }
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45328 wxPyEndAllowThreads(__tstate);
45329 if (PyErr_Occurred()) SWIG_fail;
45330 }
45331 resultobj = SWIG_Py_Void();
45332 return resultobj;
45333 fail:
45334 return NULL;
45335 }
45336
45337
45338 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45339 PyObject *resultobj = 0;
45340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45341 wxSize result;
45342 void *argp1 = 0 ;
45343 int res1 = 0 ;
45344 PyObject *swig_obj[1] ;
45345
45346 if (!args) SWIG_fail;
45347 swig_obj[0] = args;
45348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45351 }
45352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45353 {
45354 PyThreadState* __tstate = wxPyBeginAllowThreads();
45355 result = (arg1)->GetMinSize();
45356 wxPyEndAllowThreads(__tstate);
45357 if (PyErr_Occurred()) SWIG_fail;
45358 }
45359 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45360 return resultobj;
45361 fail:
45362 return NULL;
45363 }
45364
45365
45366 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45367 PyObject *resultobj = 0;
45368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45369 wxSize result;
45370 void *argp1 = 0 ;
45371 int res1 = 0 ;
45372 PyObject *swig_obj[1] ;
45373
45374 if (!args) SWIG_fail;
45375 swig_obj[0] = args;
45376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45377 if (!SWIG_IsOK(res1)) {
45378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45379 }
45380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45381 {
45382 PyThreadState* __tstate = wxPyBeginAllowThreads();
45383 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45384 wxPyEndAllowThreads(__tstate);
45385 if (PyErr_Occurred()) SWIG_fail;
45386 }
45387 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45388 return resultobj;
45389 fail:
45390 return NULL;
45391 }
45392
45393
45394 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45395 PyObject *resultobj = 0;
45396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45397 int arg2 ;
45398 int arg3 ;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 int val2 ;
45402 int ecode2 = 0 ;
45403 int val3 ;
45404 int ecode3 = 0 ;
45405 PyObject * obj0 = 0 ;
45406 PyObject * obj1 = 0 ;
45407 PyObject * obj2 = 0 ;
45408 char * kwnames[] = {
45409 (char *) "self",(char *) "x",(char *) "y", NULL
45410 };
45411
45412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45414 if (!SWIG_IsOK(res1)) {
45415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45416 }
45417 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45418 ecode2 = SWIG_AsVal_int(obj1, &val2);
45419 if (!SWIG_IsOK(ecode2)) {
45420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45421 }
45422 arg2 = static_cast< int >(val2);
45423 ecode3 = SWIG_AsVal_int(obj2, &val3);
45424 if (!SWIG_IsOK(ecode3)) {
45425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45426 }
45427 arg3 = static_cast< int >(val3);
45428 {
45429 PyThreadState* __tstate = wxPyBeginAllowThreads();
45430 (arg1)->SetInitSize(arg2,arg3);
45431 wxPyEndAllowThreads(__tstate);
45432 if (PyErr_Occurred()) SWIG_fail;
45433 }
45434 resultobj = SWIG_Py_Void();
45435 return resultobj;
45436 fail:
45437 return NULL;
45438 }
45439
45440
45441 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45442 PyObject *resultobj = 0;
45443 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45444 int arg2 ;
45445 int arg3 ;
45446 void *argp1 = 0 ;
45447 int res1 = 0 ;
45448 int val2 ;
45449 int ecode2 = 0 ;
45450 int val3 ;
45451 int ecode3 = 0 ;
45452 PyObject * obj0 = 0 ;
45453 PyObject * obj1 = 0 ;
45454 PyObject * obj2 = 0 ;
45455 char * kwnames[] = {
45456 (char *) "self",(char *) "width",(char *) "height", NULL
45457 };
45458
45459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45461 if (!SWIG_IsOK(res1)) {
45462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45463 }
45464 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45465 ecode2 = SWIG_AsVal_int(obj1, &val2);
45466 if (!SWIG_IsOK(ecode2)) {
45467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45468 }
45469 arg2 = static_cast< int >(val2);
45470 ecode3 = SWIG_AsVal_int(obj2, &val3);
45471 if (!SWIG_IsOK(ecode3)) {
45472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45473 }
45474 arg3 = static_cast< int >(val3);
45475 {
45476 PyThreadState* __tstate = wxPyBeginAllowThreads();
45477 (arg1)->SetRatio(arg2,arg3);
45478 wxPyEndAllowThreads(__tstate);
45479 if (PyErr_Occurred()) SWIG_fail;
45480 }
45481 resultobj = SWIG_Py_Void();
45482 return resultobj;
45483 fail:
45484 return NULL;
45485 }
45486
45487
45488 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45489 PyObject *resultobj = 0;
45490 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45491 wxSize *arg2 = 0 ;
45492 void *argp1 = 0 ;
45493 int res1 = 0 ;
45494 wxSize temp2 ;
45495 PyObject * obj0 = 0 ;
45496 PyObject * obj1 = 0 ;
45497 char * kwnames[] = {
45498 (char *) "self",(char *) "size", NULL
45499 };
45500
45501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45503 if (!SWIG_IsOK(res1)) {
45504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45505 }
45506 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45507 {
45508 arg2 = &temp2;
45509 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45510 }
45511 {
45512 PyThreadState* __tstate = wxPyBeginAllowThreads();
45513 (arg1)->SetRatio((wxSize const &)*arg2);
45514 wxPyEndAllowThreads(__tstate);
45515 if (PyErr_Occurred()) SWIG_fail;
45516 }
45517 resultobj = SWIG_Py_Void();
45518 return resultobj;
45519 fail:
45520 return NULL;
45521 }
45522
45523
45524 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45525 PyObject *resultobj = 0;
45526 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45527 float arg2 ;
45528 void *argp1 = 0 ;
45529 int res1 = 0 ;
45530 float val2 ;
45531 int ecode2 = 0 ;
45532 PyObject * obj0 = 0 ;
45533 PyObject * obj1 = 0 ;
45534 char * kwnames[] = {
45535 (char *) "self",(char *) "ratio", NULL
45536 };
45537
45538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45542 }
45543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45544 ecode2 = SWIG_AsVal_float(obj1, &val2);
45545 if (!SWIG_IsOK(ecode2)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45547 }
45548 arg2 = static_cast< float >(val2);
45549 {
45550 PyThreadState* __tstate = wxPyBeginAllowThreads();
45551 (arg1)->SetRatio(arg2);
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 resultobj = SWIG_Py_Void();
45556 return resultobj;
45557 fail:
45558 return NULL;
45559 }
45560
45561
45562 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45563 PyObject *resultobj = 0;
45564 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45565 float result;
45566 void *argp1 = 0 ;
45567 int res1 = 0 ;
45568 PyObject *swig_obj[1] ;
45569
45570 if (!args) SWIG_fail;
45571 swig_obj[0] = args;
45572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45573 if (!SWIG_IsOK(res1)) {
45574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45575 }
45576 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45577 {
45578 PyThreadState* __tstate = wxPyBeginAllowThreads();
45579 result = (float)(arg1)->GetRatio();
45580 wxPyEndAllowThreads(__tstate);
45581 if (PyErr_Occurred()) SWIG_fail;
45582 }
45583 resultobj = SWIG_From_float(static_cast< float >(result));
45584 return resultobj;
45585 fail:
45586 return NULL;
45587 }
45588
45589
45590 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45591 PyObject *resultobj = 0;
45592 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45593 wxRect result;
45594 void *argp1 = 0 ;
45595 int res1 = 0 ;
45596 PyObject *swig_obj[1] ;
45597
45598 if (!args) SWIG_fail;
45599 swig_obj[0] = args;
45600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45601 if (!SWIG_IsOK(res1)) {
45602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45603 }
45604 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45605 {
45606 PyThreadState* __tstate = wxPyBeginAllowThreads();
45607 result = (arg1)->GetRect();
45608 wxPyEndAllowThreads(__tstate);
45609 if (PyErr_Occurred()) SWIG_fail;
45610 }
45611 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45612 return resultobj;
45613 fail:
45614 return NULL;
45615 }
45616
45617
45618 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45619 PyObject *resultobj = 0;
45620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45621 bool result;
45622 void *argp1 = 0 ;
45623 int res1 = 0 ;
45624 PyObject *swig_obj[1] ;
45625
45626 if (!args) SWIG_fail;
45627 swig_obj[0] = args;
45628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45629 if (!SWIG_IsOK(res1)) {
45630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45631 }
45632 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45633 {
45634 PyThreadState* __tstate = wxPyBeginAllowThreads();
45635 result = (bool)(arg1)->IsWindow();
45636 wxPyEndAllowThreads(__tstate);
45637 if (PyErr_Occurred()) SWIG_fail;
45638 }
45639 {
45640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45641 }
45642 return resultobj;
45643 fail:
45644 return NULL;
45645 }
45646
45647
45648 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45649 PyObject *resultobj = 0;
45650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45651 bool result;
45652 void *argp1 = 0 ;
45653 int res1 = 0 ;
45654 PyObject *swig_obj[1] ;
45655
45656 if (!args) SWIG_fail;
45657 swig_obj[0] = args;
45658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45659 if (!SWIG_IsOK(res1)) {
45660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45661 }
45662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (bool)(arg1)->IsSizer();
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 {
45670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45671 }
45672 return resultobj;
45673 fail:
45674 return NULL;
45675 }
45676
45677
45678 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45679 PyObject *resultobj = 0;
45680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45681 bool result;
45682 void *argp1 = 0 ;
45683 int res1 = 0 ;
45684 PyObject *swig_obj[1] ;
45685
45686 if (!args) SWIG_fail;
45687 swig_obj[0] = args;
45688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45689 if (!SWIG_IsOK(res1)) {
45690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45691 }
45692 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45693 {
45694 PyThreadState* __tstate = wxPyBeginAllowThreads();
45695 result = (bool)(arg1)->IsSpacer();
45696 wxPyEndAllowThreads(__tstate);
45697 if (PyErr_Occurred()) SWIG_fail;
45698 }
45699 {
45700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45701 }
45702 return resultobj;
45703 fail:
45704 return NULL;
45705 }
45706
45707
45708 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45709 PyObject *resultobj = 0;
45710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45711 int arg2 ;
45712 void *argp1 = 0 ;
45713 int res1 = 0 ;
45714 int val2 ;
45715 int ecode2 = 0 ;
45716 PyObject * obj0 = 0 ;
45717 PyObject * obj1 = 0 ;
45718 char * kwnames[] = {
45719 (char *) "self",(char *) "proportion", NULL
45720 };
45721
45722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45724 if (!SWIG_IsOK(res1)) {
45725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45726 }
45727 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45728 ecode2 = SWIG_AsVal_int(obj1, &val2);
45729 if (!SWIG_IsOK(ecode2)) {
45730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45731 }
45732 arg2 = static_cast< int >(val2);
45733 {
45734 PyThreadState* __tstate = wxPyBeginAllowThreads();
45735 (arg1)->SetProportion(arg2);
45736 wxPyEndAllowThreads(__tstate);
45737 if (PyErr_Occurred()) SWIG_fail;
45738 }
45739 resultobj = SWIG_Py_Void();
45740 return resultobj;
45741 fail:
45742 return NULL;
45743 }
45744
45745
45746 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45747 PyObject *resultobj = 0;
45748 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45749 int result;
45750 void *argp1 = 0 ;
45751 int res1 = 0 ;
45752 PyObject *swig_obj[1] ;
45753
45754 if (!args) SWIG_fail;
45755 swig_obj[0] = args;
45756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45757 if (!SWIG_IsOK(res1)) {
45758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45759 }
45760 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45761 {
45762 PyThreadState* __tstate = wxPyBeginAllowThreads();
45763 result = (int)(arg1)->GetProportion();
45764 wxPyEndAllowThreads(__tstate);
45765 if (PyErr_Occurred()) SWIG_fail;
45766 }
45767 resultobj = SWIG_From_int(static_cast< int >(result));
45768 return resultobj;
45769 fail:
45770 return NULL;
45771 }
45772
45773
45774 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45775 PyObject *resultobj = 0;
45776 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45777 int arg2 ;
45778 void *argp1 = 0 ;
45779 int res1 = 0 ;
45780 int val2 ;
45781 int ecode2 = 0 ;
45782 PyObject * obj0 = 0 ;
45783 PyObject * obj1 = 0 ;
45784 char * kwnames[] = {
45785 (char *) "self",(char *) "flag", NULL
45786 };
45787
45788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45790 if (!SWIG_IsOK(res1)) {
45791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45792 }
45793 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45794 ecode2 = SWIG_AsVal_int(obj1, &val2);
45795 if (!SWIG_IsOK(ecode2)) {
45796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45797 }
45798 arg2 = static_cast< int >(val2);
45799 {
45800 PyThreadState* __tstate = wxPyBeginAllowThreads();
45801 (arg1)->SetFlag(arg2);
45802 wxPyEndAllowThreads(__tstate);
45803 if (PyErr_Occurred()) SWIG_fail;
45804 }
45805 resultobj = SWIG_Py_Void();
45806 return resultobj;
45807 fail:
45808 return NULL;
45809 }
45810
45811
45812 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45813 PyObject *resultobj = 0;
45814 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45815 int result;
45816 void *argp1 = 0 ;
45817 int res1 = 0 ;
45818 PyObject *swig_obj[1] ;
45819
45820 if (!args) SWIG_fail;
45821 swig_obj[0] = args;
45822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45823 if (!SWIG_IsOK(res1)) {
45824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45825 }
45826 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45827 {
45828 PyThreadState* __tstate = wxPyBeginAllowThreads();
45829 result = (int)(arg1)->GetFlag();
45830 wxPyEndAllowThreads(__tstate);
45831 if (PyErr_Occurred()) SWIG_fail;
45832 }
45833 resultobj = SWIG_From_int(static_cast< int >(result));
45834 return resultobj;
45835 fail:
45836 return NULL;
45837 }
45838
45839
45840 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45841 PyObject *resultobj = 0;
45842 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45843 int arg2 ;
45844 void *argp1 = 0 ;
45845 int res1 = 0 ;
45846 int val2 ;
45847 int ecode2 = 0 ;
45848 PyObject * obj0 = 0 ;
45849 PyObject * obj1 = 0 ;
45850 char * kwnames[] = {
45851 (char *) "self",(char *) "border", NULL
45852 };
45853
45854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45856 if (!SWIG_IsOK(res1)) {
45857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45858 }
45859 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45860 ecode2 = SWIG_AsVal_int(obj1, &val2);
45861 if (!SWIG_IsOK(ecode2)) {
45862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45863 }
45864 arg2 = static_cast< int >(val2);
45865 {
45866 PyThreadState* __tstate = wxPyBeginAllowThreads();
45867 (arg1)->SetBorder(arg2);
45868 wxPyEndAllowThreads(__tstate);
45869 if (PyErr_Occurred()) SWIG_fail;
45870 }
45871 resultobj = SWIG_Py_Void();
45872 return resultobj;
45873 fail:
45874 return NULL;
45875 }
45876
45877
45878 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45879 PyObject *resultobj = 0;
45880 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45881 int result;
45882 void *argp1 = 0 ;
45883 int res1 = 0 ;
45884 PyObject *swig_obj[1] ;
45885
45886 if (!args) SWIG_fail;
45887 swig_obj[0] = args;
45888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45889 if (!SWIG_IsOK(res1)) {
45890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45891 }
45892 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45893 {
45894 PyThreadState* __tstate = wxPyBeginAllowThreads();
45895 result = (int)(arg1)->GetBorder();
45896 wxPyEndAllowThreads(__tstate);
45897 if (PyErr_Occurred()) SWIG_fail;
45898 }
45899 resultobj = SWIG_From_int(static_cast< int >(result));
45900 return resultobj;
45901 fail:
45902 return NULL;
45903 }
45904
45905
45906 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45907 PyObject *resultobj = 0;
45908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45909 wxWindow *result = 0 ;
45910 void *argp1 = 0 ;
45911 int res1 = 0 ;
45912 PyObject *swig_obj[1] ;
45913
45914 if (!args) SWIG_fail;
45915 swig_obj[0] = args;
45916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45917 if (!SWIG_IsOK(res1)) {
45918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45919 }
45920 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45921 {
45922 PyThreadState* __tstate = wxPyBeginAllowThreads();
45923 result = (wxWindow *)(arg1)->GetWindow();
45924 wxPyEndAllowThreads(__tstate);
45925 if (PyErr_Occurred()) SWIG_fail;
45926 }
45927 {
45928 resultobj = wxPyMake_wxObject(result, 0);
45929 }
45930 return resultobj;
45931 fail:
45932 return NULL;
45933 }
45934
45935
45936 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45937 PyObject *resultobj = 0;
45938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45939 wxWindow *arg2 = (wxWindow *) 0 ;
45940 void *argp1 = 0 ;
45941 int res1 = 0 ;
45942 void *argp2 = 0 ;
45943 int res2 = 0 ;
45944 PyObject * obj0 = 0 ;
45945 PyObject * obj1 = 0 ;
45946 char * kwnames[] = {
45947 (char *) "self",(char *) "window", NULL
45948 };
45949
45950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45952 if (!SWIG_IsOK(res1)) {
45953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45954 }
45955 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45957 if (!SWIG_IsOK(res2)) {
45958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45959 }
45960 arg2 = reinterpret_cast< wxWindow * >(argp2);
45961 {
45962 PyThreadState* __tstate = wxPyBeginAllowThreads();
45963 (arg1)->SetWindow(arg2);
45964 wxPyEndAllowThreads(__tstate);
45965 if (PyErr_Occurred()) SWIG_fail;
45966 }
45967 resultobj = SWIG_Py_Void();
45968 return resultobj;
45969 fail:
45970 return NULL;
45971 }
45972
45973
45974 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45975 PyObject *resultobj = 0;
45976 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45977 wxSizer *result = 0 ;
45978 void *argp1 = 0 ;
45979 int res1 = 0 ;
45980 PyObject *swig_obj[1] ;
45981
45982 if (!args) SWIG_fail;
45983 swig_obj[0] = args;
45984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45985 if (!SWIG_IsOK(res1)) {
45986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45987 }
45988 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45989 {
45990 PyThreadState* __tstate = wxPyBeginAllowThreads();
45991 result = (wxSizer *)(arg1)->GetSizer();
45992 wxPyEndAllowThreads(__tstate);
45993 if (PyErr_Occurred()) SWIG_fail;
45994 }
45995 {
45996 resultobj = wxPyMake_wxObject(result, (bool)0);
45997 }
45998 return resultobj;
45999 fail:
46000 return NULL;
46001 }
46002
46003
46004 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46005 PyObject *resultobj = 0;
46006 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46007 wxSizer *arg2 = (wxSizer *) 0 ;
46008 void *argp1 = 0 ;
46009 int res1 = 0 ;
46010 int res2 = 0 ;
46011 PyObject * obj0 = 0 ;
46012 PyObject * obj1 = 0 ;
46013 char * kwnames[] = {
46014 (char *) "self",(char *) "sizer", NULL
46015 };
46016
46017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46019 if (!SWIG_IsOK(res1)) {
46020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46021 }
46022 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46023 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46024 if (!SWIG_IsOK(res2)) {
46025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46026 }
46027 {
46028 PyThreadState* __tstate = wxPyBeginAllowThreads();
46029 (arg1)->SetSizer(arg2);
46030 wxPyEndAllowThreads(__tstate);
46031 if (PyErr_Occurred()) SWIG_fail;
46032 }
46033 resultobj = SWIG_Py_Void();
46034 return resultobj;
46035 fail:
46036 return NULL;
46037 }
46038
46039
46040 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46041 PyObject *resultobj = 0;
46042 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46043 wxSize *result = 0 ;
46044 void *argp1 = 0 ;
46045 int res1 = 0 ;
46046 PyObject *swig_obj[1] ;
46047
46048 if (!args) SWIG_fail;
46049 swig_obj[0] = args;
46050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46051 if (!SWIG_IsOK(res1)) {
46052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46053 }
46054 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46055 {
46056 PyThreadState* __tstate = wxPyBeginAllowThreads();
46057 {
46058 wxSize const &_result_ref = (arg1)->GetSpacer();
46059 result = (wxSize *) &_result_ref;
46060 }
46061 wxPyEndAllowThreads(__tstate);
46062 if (PyErr_Occurred()) SWIG_fail;
46063 }
46064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46065 return resultobj;
46066 fail:
46067 return NULL;
46068 }
46069
46070
46071 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46072 PyObject *resultobj = 0;
46073 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46074 wxSize *arg2 = 0 ;
46075 void *argp1 = 0 ;
46076 int res1 = 0 ;
46077 wxSize temp2 ;
46078 PyObject * obj0 = 0 ;
46079 PyObject * obj1 = 0 ;
46080 char * kwnames[] = {
46081 (char *) "self",(char *) "size", NULL
46082 };
46083
46084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46086 if (!SWIG_IsOK(res1)) {
46087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46088 }
46089 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46090 {
46091 arg2 = &temp2;
46092 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46093 }
46094 {
46095 PyThreadState* __tstate = wxPyBeginAllowThreads();
46096 (arg1)->SetSpacer((wxSize const &)*arg2);
46097 wxPyEndAllowThreads(__tstate);
46098 if (PyErr_Occurred()) SWIG_fail;
46099 }
46100 resultobj = SWIG_Py_Void();
46101 return resultobj;
46102 fail:
46103 return NULL;
46104 }
46105
46106
46107 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46108 PyObject *resultobj = 0;
46109 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46110 bool arg2 ;
46111 void *argp1 = 0 ;
46112 int res1 = 0 ;
46113 bool val2 ;
46114 int ecode2 = 0 ;
46115 PyObject * obj0 = 0 ;
46116 PyObject * obj1 = 0 ;
46117 char * kwnames[] = {
46118 (char *) "self",(char *) "show", NULL
46119 };
46120
46121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46123 if (!SWIG_IsOK(res1)) {
46124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46125 }
46126 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46127 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46128 if (!SWIG_IsOK(ecode2)) {
46129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46130 }
46131 arg2 = static_cast< bool >(val2);
46132 {
46133 PyThreadState* __tstate = wxPyBeginAllowThreads();
46134 (arg1)->Show(arg2);
46135 wxPyEndAllowThreads(__tstate);
46136 if (PyErr_Occurred()) SWIG_fail;
46137 }
46138 resultobj = SWIG_Py_Void();
46139 return resultobj;
46140 fail:
46141 return NULL;
46142 }
46143
46144
46145 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46146 PyObject *resultobj = 0;
46147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46148 bool result;
46149 void *argp1 = 0 ;
46150 int res1 = 0 ;
46151 PyObject *swig_obj[1] ;
46152
46153 if (!args) SWIG_fail;
46154 swig_obj[0] = args;
46155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46156 if (!SWIG_IsOK(res1)) {
46157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46158 }
46159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46160 {
46161 PyThreadState* __tstate = wxPyBeginAllowThreads();
46162 result = (bool)(arg1)->IsShown();
46163 wxPyEndAllowThreads(__tstate);
46164 if (PyErr_Occurred()) SWIG_fail;
46165 }
46166 {
46167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46168 }
46169 return resultobj;
46170 fail:
46171 return NULL;
46172 }
46173
46174
46175 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46176 PyObject *resultobj = 0;
46177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46178 wxPoint result;
46179 void *argp1 = 0 ;
46180 int res1 = 0 ;
46181 PyObject *swig_obj[1] ;
46182
46183 if (!args) SWIG_fail;
46184 swig_obj[0] = args;
46185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46186 if (!SWIG_IsOK(res1)) {
46187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46188 }
46189 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46190 {
46191 PyThreadState* __tstate = wxPyBeginAllowThreads();
46192 result = (arg1)->GetPosition();
46193 wxPyEndAllowThreads(__tstate);
46194 if (PyErr_Occurred()) SWIG_fail;
46195 }
46196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46197 return resultobj;
46198 fail:
46199 return NULL;
46200 }
46201
46202
46203 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46204 PyObject *resultobj = 0;
46205 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46206 PyObject *result = 0 ;
46207 void *argp1 = 0 ;
46208 int res1 = 0 ;
46209 PyObject *swig_obj[1] ;
46210
46211 if (!args) SWIG_fail;
46212 swig_obj[0] = args;
46213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46214 if (!SWIG_IsOK(res1)) {
46215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46216 }
46217 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46218 {
46219 PyThreadState* __tstate = wxPyBeginAllowThreads();
46220 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46221 wxPyEndAllowThreads(__tstate);
46222 if (PyErr_Occurred()) SWIG_fail;
46223 }
46224 resultobj = result;
46225 return resultobj;
46226 fail:
46227 return NULL;
46228 }
46229
46230
46231 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46232 PyObject *resultobj = 0;
46233 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46234 PyObject *arg2 = (PyObject *) 0 ;
46235 void *argp1 = 0 ;
46236 int res1 = 0 ;
46237 PyObject * obj0 = 0 ;
46238 PyObject * obj1 = 0 ;
46239 char * kwnames[] = {
46240 (char *) "self",(char *) "userData", NULL
46241 };
46242
46243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46245 if (!SWIG_IsOK(res1)) {
46246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46247 }
46248 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46249 arg2 = obj1;
46250 {
46251 PyThreadState* __tstate = wxPyBeginAllowThreads();
46252 wxSizerItem_SetUserData(arg1,arg2);
46253 wxPyEndAllowThreads(__tstate);
46254 if (PyErr_Occurred()) SWIG_fail;
46255 }
46256 resultobj = SWIG_Py_Void();
46257 return resultobj;
46258 fail:
46259 return NULL;
46260 }
46261
46262
46263 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46264 PyObject *obj;
46265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46266 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46267 return SWIG_Py_Void();
46268 }
46269
46270 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46271 return SWIG_Python_InitShadowInstance(args);
46272 }
46273
46274 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46275 PyObject *resultobj = 0;
46276 wxSizer *arg1 = (wxSizer *) 0 ;
46277 void *argp1 = 0 ;
46278 int res1 = 0 ;
46279 PyObject *swig_obj[1] ;
46280
46281 if (!args) SWIG_fail;
46282 swig_obj[0] = args;
46283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46284 if (!SWIG_IsOK(res1)) {
46285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46286 }
46287 arg1 = reinterpret_cast< wxSizer * >(argp1);
46288 {
46289 PyThreadState* __tstate = wxPyBeginAllowThreads();
46290 delete arg1;
46291
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_Py_Void();
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46303 PyObject *resultobj = 0;
46304 wxSizer *arg1 = (wxSizer *) 0 ;
46305 PyObject *arg2 = (PyObject *) 0 ;
46306 void *argp1 = 0 ;
46307 int res1 = 0 ;
46308 PyObject * obj0 = 0 ;
46309 PyObject * obj1 = 0 ;
46310 char * kwnames[] = {
46311 (char *) "self",(char *) "_self", NULL
46312 };
46313
46314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46316 if (!SWIG_IsOK(res1)) {
46317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46318 }
46319 arg1 = reinterpret_cast< wxSizer * >(argp1);
46320 arg2 = obj1;
46321 {
46322 PyThreadState* __tstate = wxPyBeginAllowThreads();
46323 wxSizer__setOORInfo(arg1,arg2);
46324 wxPyEndAllowThreads(__tstate);
46325 if (PyErr_Occurred()) SWIG_fail;
46326 }
46327 resultobj = SWIG_Py_Void();
46328 return resultobj;
46329 fail:
46330 return NULL;
46331 }
46332
46333
46334 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46335 PyObject *resultobj = 0;
46336 wxSizer *arg1 = (wxSizer *) 0 ;
46337 PyObject *arg2 = (PyObject *) 0 ;
46338 int arg3 = (int) 0 ;
46339 int arg4 = (int) 0 ;
46340 int arg5 = (int) 0 ;
46341 PyObject *arg6 = (PyObject *) NULL ;
46342 wxSizerItem *result = 0 ;
46343 void *argp1 = 0 ;
46344 int res1 = 0 ;
46345 int val3 ;
46346 int ecode3 = 0 ;
46347 int val4 ;
46348 int ecode4 = 0 ;
46349 int val5 ;
46350 int ecode5 = 0 ;
46351 PyObject * obj0 = 0 ;
46352 PyObject * obj1 = 0 ;
46353 PyObject * obj2 = 0 ;
46354 PyObject * obj3 = 0 ;
46355 PyObject * obj4 = 0 ;
46356 PyObject * obj5 = 0 ;
46357 char * kwnames[] = {
46358 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46359 };
46360
46361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46363 if (!SWIG_IsOK(res1)) {
46364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46365 }
46366 arg1 = reinterpret_cast< wxSizer * >(argp1);
46367 arg2 = obj1;
46368 if (obj2) {
46369 ecode3 = SWIG_AsVal_int(obj2, &val3);
46370 if (!SWIG_IsOK(ecode3)) {
46371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46372 }
46373 arg3 = static_cast< int >(val3);
46374 }
46375 if (obj3) {
46376 ecode4 = SWIG_AsVal_int(obj3, &val4);
46377 if (!SWIG_IsOK(ecode4)) {
46378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46379 }
46380 arg4 = static_cast< int >(val4);
46381 }
46382 if (obj4) {
46383 ecode5 = SWIG_AsVal_int(obj4, &val5);
46384 if (!SWIG_IsOK(ecode5)) {
46385 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46386 }
46387 arg5 = static_cast< int >(val5);
46388 }
46389 if (obj5) {
46390 arg6 = obj5;
46391 }
46392 {
46393 PyThreadState* __tstate = wxPyBeginAllowThreads();
46394 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46395 wxPyEndAllowThreads(__tstate);
46396 if (PyErr_Occurred()) SWIG_fail;
46397 }
46398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46399 return resultobj;
46400 fail:
46401 return NULL;
46402 }
46403
46404
46405 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46406 PyObject *resultobj = 0;
46407 wxSizer *arg1 = (wxSizer *) 0 ;
46408 int arg2 ;
46409 PyObject *arg3 = (PyObject *) 0 ;
46410 int arg4 = (int) 0 ;
46411 int arg5 = (int) 0 ;
46412 int arg6 = (int) 0 ;
46413 PyObject *arg7 = (PyObject *) NULL ;
46414 wxSizerItem *result = 0 ;
46415 void *argp1 = 0 ;
46416 int res1 = 0 ;
46417 int val2 ;
46418 int ecode2 = 0 ;
46419 int val4 ;
46420 int ecode4 = 0 ;
46421 int val5 ;
46422 int ecode5 = 0 ;
46423 int val6 ;
46424 int ecode6 = 0 ;
46425 PyObject * obj0 = 0 ;
46426 PyObject * obj1 = 0 ;
46427 PyObject * obj2 = 0 ;
46428 PyObject * obj3 = 0 ;
46429 PyObject * obj4 = 0 ;
46430 PyObject * obj5 = 0 ;
46431 PyObject * obj6 = 0 ;
46432 char * kwnames[] = {
46433 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46434 };
46435
46436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46438 if (!SWIG_IsOK(res1)) {
46439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46440 }
46441 arg1 = reinterpret_cast< wxSizer * >(argp1);
46442 ecode2 = SWIG_AsVal_int(obj1, &val2);
46443 if (!SWIG_IsOK(ecode2)) {
46444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46445 }
46446 arg2 = static_cast< int >(val2);
46447 arg3 = obj2;
46448 if (obj3) {
46449 ecode4 = SWIG_AsVal_int(obj3, &val4);
46450 if (!SWIG_IsOK(ecode4)) {
46451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46452 }
46453 arg4 = static_cast< int >(val4);
46454 }
46455 if (obj4) {
46456 ecode5 = SWIG_AsVal_int(obj4, &val5);
46457 if (!SWIG_IsOK(ecode5)) {
46458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46459 }
46460 arg5 = static_cast< int >(val5);
46461 }
46462 if (obj5) {
46463 ecode6 = SWIG_AsVal_int(obj5, &val6);
46464 if (!SWIG_IsOK(ecode6)) {
46465 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46466 }
46467 arg6 = static_cast< int >(val6);
46468 }
46469 if (obj6) {
46470 arg7 = obj6;
46471 }
46472 {
46473 PyThreadState* __tstate = wxPyBeginAllowThreads();
46474 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46475 wxPyEndAllowThreads(__tstate);
46476 if (PyErr_Occurred()) SWIG_fail;
46477 }
46478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46479 return resultobj;
46480 fail:
46481 return NULL;
46482 }
46483
46484
46485 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46486 PyObject *resultobj = 0;
46487 wxSizer *arg1 = (wxSizer *) 0 ;
46488 PyObject *arg2 = (PyObject *) 0 ;
46489 int arg3 = (int) 0 ;
46490 int arg4 = (int) 0 ;
46491 int arg5 = (int) 0 ;
46492 PyObject *arg6 = (PyObject *) NULL ;
46493 wxSizerItem *result = 0 ;
46494 void *argp1 = 0 ;
46495 int res1 = 0 ;
46496 int val3 ;
46497 int ecode3 = 0 ;
46498 int val4 ;
46499 int ecode4 = 0 ;
46500 int val5 ;
46501 int ecode5 = 0 ;
46502 PyObject * obj0 = 0 ;
46503 PyObject * obj1 = 0 ;
46504 PyObject * obj2 = 0 ;
46505 PyObject * obj3 = 0 ;
46506 PyObject * obj4 = 0 ;
46507 PyObject * obj5 = 0 ;
46508 char * kwnames[] = {
46509 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46510 };
46511
46512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46514 if (!SWIG_IsOK(res1)) {
46515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46516 }
46517 arg1 = reinterpret_cast< wxSizer * >(argp1);
46518 arg2 = obj1;
46519 if (obj2) {
46520 ecode3 = SWIG_AsVal_int(obj2, &val3);
46521 if (!SWIG_IsOK(ecode3)) {
46522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46523 }
46524 arg3 = static_cast< int >(val3);
46525 }
46526 if (obj3) {
46527 ecode4 = SWIG_AsVal_int(obj3, &val4);
46528 if (!SWIG_IsOK(ecode4)) {
46529 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46530 }
46531 arg4 = static_cast< int >(val4);
46532 }
46533 if (obj4) {
46534 ecode5 = SWIG_AsVal_int(obj4, &val5);
46535 if (!SWIG_IsOK(ecode5)) {
46536 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46537 }
46538 arg5 = static_cast< int >(val5);
46539 }
46540 if (obj5) {
46541 arg6 = obj5;
46542 }
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46557 PyObject *resultobj = 0;
46558 wxSizer *arg1 = (wxSizer *) 0 ;
46559 PyObject *arg2 = (PyObject *) 0 ;
46560 bool result;
46561 void *argp1 = 0 ;
46562 int res1 = 0 ;
46563 PyObject * obj0 = 0 ;
46564 PyObject * obj1 = 0 ;
46565 char * kwnames[] = {
46566 (char *) "self",(char *) "item", NULL
46567 };
46568
46569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46571 if (!SWIG_IsOK(res1)) {
46572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46573 }
46574 arg1 = reinterpret_cast< wxSizer * >(argp1);
46575 arg2 = obj1;
46576 {
46577 PyThreadState* __tstate = wxPyBeginAllowThreads();
46578 result = (bool)wxSizer_Remove(arg1,arg2);
46579 wxPyEndAllowThreads(__tstate);
46580 if (PyErr_Occurred()) SWIG_fail;
46581 }
46582 {
46583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46584 }
46585 return resultobj;
46586 fail:
46587 return NULL;
46588 }
46589
46590
46591 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46592 PyObject *resultobj = 0;
46593 wxSizer *arg1 = (wxSizer *) 0 ;
46594 PyObject *arg2 = (PyObject *) 0 ;
46595 bool result;
46596 void *argp1 = 0 ;
46597 int res1 = 0 ;
46598 PyObject * obj0 = 0 ;
46599 PyObject * obj1 = 0 ;
46600 char * kwnames[] = {
46601 (char *) "self",(char *) "item", NULL
46602 };
46603
46604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46606 if (!SWIG_IsOK(res1)) {
46607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46608 }
46609 arg1 = reinterpret_cast< wxSizer * >(argp1);
46610 arg2 = obj1;
46611 {
46612 PyThreadState* __tstate = wxPyBeginAllowThreads();
46613 result = (bool)wxSizer_Detach(arg1,arg2);
46614 wxPyEndAllowThreads(__tstate);
46615 if (PyErr_Occurred()) SWIG_fail;
46616 }
46617 {
46618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46619 }
46620 return resultobj;
46621 fail:
46622 return NULL;
46623 }
46624
46625
46626 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46627 PyObject *resultobj = 0;
46628 wxSizer *arg1 = (wxSizer *) 0 ;
46629 PyObject *arg2 = (PyObject *) 0 ;
46630 wxSizerItem *result = 0 ;
46631 void *argp1 = 0 ;
46632 int res1 = 0 ;
46633 PyObject * obj0 = 0 ;
46634 PyObject * obj1 = 0 ;
46635 char * kwnames[] = {
46636 (char *) "self",(char *) "item", NULL
46637 };
46638
46639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46641 if (!SWIG_IsOK(res1)) {
46642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46643 }
46644 arg1 = reinterpret_cast< wxSizer * >(argp1);
46645 arg2 = obj1;
46646 {
46647 PyThreadState* __tstate = wxPyBeginAllowThreads();
46648 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46649 wxPyEndAllowThreads(__tstate);
46650 if (PyErr_Occurred()) SWIG_fail;
46651 }
46652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46653 return resultobj;
46654 fail:
46655 return NULL;
46656 }
46657
46658
46659 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46660 PyObject *resultobj = 0;
46661 wxSizer *arg1 = (wxSizer *) 0 ;
46662 PyObject *arg2 = (PyObject *) 0 ;
46663 wxSize *arg3 = 0 ;
46664 void *argp1 = 0 ;
46665 int res1 = 0 ;
46666 wxSize temp3 ;
46667 PyObject * obj0 = 0 ;
46668 PyObject * obj1 = 0 ;
46669 PyObject * obj2 = 0 ;
46670 char * kwnames[] = {
46671 (char *) "self",(char *) "item",(char *) "size", NULL
46672 };
46673
46674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46676 if (!SWIG_IsOK(res1)) {
46677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46678 }
46679 arg1 = reinterpret_cast< wxSizer * >(argp1);
46680 arg2 = obj1;
46681 {
46682 arg3 = &temp3;
46683 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46684 }
46685 {
46686 PyThreadState* __tstate = wxPyBeginAllowThreads();
46687 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46688 wxPyEndAllowThreads(__tstate);
46689 if (PyErr_Occurred()) SWIG_fail;
46690 }
46691 resultobj = SWIG_Py_Void();
46692 return resultobj;
46693 fail:
46694 return NULL;
46695 }
46696
46697
46698 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46699 PyObject *resultobj = 0;
46700 wxSizer *arg1 = (wxSizer *) 0 ;
46701 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46702 wxSizerItem *result = 0 ;
46703 void *argp1 = 0 ;
46704 int res1 = 0 ;
46705 int res2 = 0 ;
46706 PyObject * obj0 = 0 ;
46707 PyObject * obj1 = 0 ;
46708 char * kwnames[] = {
46709 (char *) "self",(char *) "item", NULL
46710 };
46711
46712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46714 if (!SWIG_IsOK(res1)) {
46715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46716 }
46717 arg1 = reinterpret_cast< wxSizer * >(argp1);
46718 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46719 if (!SWIG_IsOK(res2)) {
46720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46721 }
46722 {
46723 PyThreadState* __tstate = wxPyBeginAllowThreads();
46724 result = (wxSizerItem *)(arg1)->Add(arg2);
46725 wxPyEndAllowThreads(__tstate);
46726 if (PyErr_Occurred()) SWIG_fail;
46727 }
46728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46729 return resultobj;
46730 fail:
46731 return NULL;
46732 }
46733
46734
46735 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46736 PyObject *resultobj = 0;
46737 wxSizer *arg1 = (wxSizer *) 0 ;
46738 size_t arg2 ;
46739 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46740 wxSizerItem *result = 0 ;
46741 void *argp1 = 0 ;
46742 int res1 = 0 ;
46743 size_t val2 ;
46744 int ecode2 = 0 ;
46745 int res3 = 0 ;
46746 PyObject * obj0 = 0 ;
46747 PyObject * obj1 = 0 ;
46748 PyObject * obj2 = 0 ;
46749 char * kwnames[] = {
46750 (char *) "self",(char *) "index",(char *) "item", NULL
46751 };
46752
46753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46757 }
46758 arg1 = reinterpret_cast< wxSizer * >(argp1);
46759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46760 if (!SWIG_IsOK(ecode2)) {
46761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46762 }
46763 arg2 = static_cast< size_t >(val2);
46764 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46765 if (!SWIG_IsOK(res3)) {
46766 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46767 }
46768 {
46769 PyThreadState* __tstate = wxPyBeginAllowThreads();
46770 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46782 PyObject *resultobj = 0;
46783 wxSizer *arg1 = (wxSizer *) 0 ;
46784 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46785 wxSizerItem *result = 0 ;
46786 void *argp1 = 0 ;
46787 int res1 = 0 ;
46788 int res2 = 0 ;
46789 PyObject * obj0 = 0 ;
46790 PyObject * obj1 = 0 ;
46791 char * kwnames[] = {
46792 (char *) "self",(char *) "item", NULL
46793 };
46794
46795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46797 if (!SWIG_IsOK(res1)) {
46798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46799 }
46800 arg1 = reinterpret_cast< wxSizer * >(argp1);
46801 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46802 if (!SWIG_IsOK(res2)) {
46803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46804 }
46805 {
46806 PyThreadState* __tstate = wxPyBeginAllowThreads();
46807 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46808 wxPyEndAllowThreads(__tstate);
46809 if (PyErr_Occurred()) SWIG_fail;
46810 }
46811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46812 return resultobj;
46813 fail:
46814 return NULL;
46815 }
46816
46817
46818 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46819 PyObject *resultobj = 0;
46820 wxSizer *arg1 = (wxSizer *) 0 ;
46821 int arg2 ;
46822 int arg3 ;
46823 int arg4 ;
46824 int arg5 ;
46825 void *argp1 = 0 ;
46826 int res1 = 0 ;
46827 int val2 ;
46828 int ecode2 = 0 ;
46829 int val3 ;
46830 int ecode3 = 0 ;
46831 int val4 ;
46832 int ecode4 = 0 ;
46833 int val5 ;
46834 int ecode5 = 0 ;
46835 PyObject * obj0 = 0 ;
46836 PyObject * obj1 = 0 ;
46837 PyObject * obj2 = 0 ;
46838 PyObject * obj3 = 0 ;
46839 PyObject * obj4 = 0 ;
46840 char * kwnames[] = {
46841 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46842 };
46843
46844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46846 if (!SWIG_IsOK(res1)) {
46847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46848 }
46849 arg1 = reinterpret_cast< wxSizer * >(argp1);
46850 ecode2 = SWIG_AsVal_int(obj1, &val2);
46851 if (!SWIG_IsOK(ecode2)) {
46852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46853 }
46854 arg2 = static_cast< int >(val2);
46855 ecode3 = SWIG_AsVal_int(obj2, &val3);
46856 if (!SWIG_IsOK(ecode3)) {
46857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46858 }
46859 arg3 = static_cast< int >(val3);
46860 ecode4 = SWIG_AsVal_int(obj3, &val4);
46861 if (!SWIG_IsOK(ecode4)) {
46862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46863 }
46864 arg4 = static_cast< int >(val4);
46865 ecode5 = SWIG_AsVal_int(obj4, &val5);
46866 if (!SWIG_IsOK(ecode5)) {
46867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46868 }
46869 arg5 = static_cast< int >(val5);
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 resultobj = SWIG_Py_Void();
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 wxSize *arg2 = 0 ;
46887 void *argp1 = 0 ;
46888 int res1 = 0 ;
46889 wxSize temp2 ;
46890 PyObject * obj0 = 0 ;
46891 PyObject * obj1 = 0 ;
46892 char * kwnames[] = {
46893 (char *) "self",(char *) "size", NULL
46894 };
46895
46896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46900 }
46901 arg1 = reinterpret_cast< wxSizer * >(argp1);
46902 {
46903 arg2 = &temp2;
46904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46905 }
46906 {
46907 PyThreadState* __tstate = wxPyBeginAllowThreads();
46908 (arg1)->SetMinSize((wxSize const &)*arg2);
46909 wxPyEndAllowThreads(__tstate);
46910 if (PyErr_Occurred()) SWIG_fail;
46911 }
46912 resultobj = SWIG_Py_Void();
46913 return resultobj;
46914 fail:
46915 return NULL;
46916 }
46917
46918
46919 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46920 PyObject *resultobj = 0;
46921 wxSizer *arg1 = (wxSizer *) 0 ;
46922 wxSize result;
46923 void *argp1 = 0 ;
46924 int res1 = 0 ;
46925 PyObject *swig_obj[1] ;
46926
46927 if (!args) SWIG_fail;
46928 swig_obj[0] = args;
46929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46930 if (!SWIG_IsOK(res1)) {
46931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46932 }
46933 arg1 = reinterpret_cast< wxSizer * >(argp1);
46934 {
46935 PyThreadState* __tstate = wxPyBeginAllowThreads();
46936 result = (arg1)->GetSize();
46937 wxPyEndAllowThreads(__tstate);
46938 if (PyErr_Occurred()) SWIG_fail;
46939 }
46940 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46941 return resultobj;
46942 fail:
46943 return NULL;
46944 }
46945
46946
46947 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46948 PyObject *resultobj = 0;
46949 wxSizer *arg1 = (wxSizer *) 0 ;
46950 wxPoint result;
46951 void *argp1 = 0 ;
46952 int res1 = 0 ;
46953 PyObject *swig_obj[1] ;
46954
46955 if (!args) SWIG_fail;
46956 swig_obj[0] = args;
46957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46960 }
46961 arg1 = reinterpret_cast< wxSizer * >(argp1);
46962 {
46963 PyThreadState* __tstate = wxPyBeginAllowThreads();
46964 result = (arg1)->GetPosition();
46965 wxPyEndAllowThreads(__tstate);
46966 if (PyErr_Occurred()) SWIG_fail;
46967 }
46968 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46969 return resultobj;
46970 fail:
46971 return NULL;
46972 }
46973
46974
46975 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46976 PyObject *resultobj = 0;
46977 wxSizer *arg1 = (wxSizer *) 0 ;
46978 wxSize result;
46979 void *argp1 = 0 ;
46980 int res1 = 0 ;
46981 PyObject *swig_obj[1] ;
46982
46983 if (!args) SWIG_fail;
46984 swig_obj[0] = args;
46985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46988 }
46989 arg1 = reinterpret_cast< wxSizer * >(argp1);
46990 {
46991 PyThreadState* __tstate = wxPyBeginAllowThreads();
46992 result = (arg1)->GetMinSize();
46993 wxPyEndAllowThreads(__tstate);
46994 if (PyErr_Occurred()) SWIG_fail;
46995 }
46996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46997 return resultobj;
46998 fail:
46999 return NULL;
47000 }
47001
47002
47003 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47004 PyObject *resultobj = 0;
47005 wxSizer *arg1 = (wxSizer *) 0 ;
47006 void *argp1 = 0 ;
47007 int res1 = 0 ;
47008 PyObject *swig_obj[1] ;
47009
47010 if (!args) SWIG_fail;
47011 swig_obj[0] = args;
47012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47013 if (!SWIG_IsOK(res1)) {
47014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47015 }
47016 arg1 = reinterpret_cast< wxSizer * >(argp1);
47017 {
47018 PyThreadState* __tstate = wxPyBeginAllowThreads();
47019 (arg1)->RecalcSizes();
47020 wxPyEndAllowThreads(__tstate);
47021 if (PyErr_Occurred()) SWIG_fail;
47022 }
47023 resultobj = SWIG_Py_Void();
47024 return resultobj;
47025 fail:
47026 return NULL;
47027 }
47028
47029
47030 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47031 PyObject *resultobj = 0;
47032 wxSizer *arg1 = (wxSizer *) 0 ;
47033 wxSize result;
47034 void *argp1 = 0 ;
47035 int res1 = 0 ;
47036 PyObject *swig_obj[1] ;
47037
47038 if (!args) SWIG_fail;
47039 swig_obj[0] = args;
47040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47041 if (!SWIG_IsOK(res1)) {
47042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47043 }
47044 arg1 = reinterpret_cast< wxSizer * >(argp1);
47045 {
47046 PyThreadState* __tstate = wxPyBeginAllowThreads();
47047 result = (arg1)->CalcMin();
47048 wxPyEndAllowThreads(__tstate);
47049 if (PyErr_Occurred()) SWIG_fail;
47050 }
47051 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47052 return resultobj;
47053 fail:
47054 return NULL;
47055 }
47056
47057
47058 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47059 PyObject *resultobj = 0;
47060 wxSizer *arg1 = (wxSizer *) 0 ;
47061 void *argp1 = 0 ;
47062 int res1 = 0 ;
47063 PyObject *swig_obj[1] ;
47064
47065 if (!args) SWIG_fail;
47066 swig_obj[0] = args;
47067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47070 }
47071 arg1 = reinterpret_cast< wxSizer * >(argp1);
47072 {
47073 PyThreadState* __tstate = wxPyBeginAllowThreads();
47074 (arg1)->Layout();
47075 wxPyEndAllowThreads(__tstate);
47076 if (PyErr_Occurred()) SWIG_fail;
47077 }
47078 resultobj = SWIG_Py_Void();
47079 return resultobj;
47080 fail:
47081 return NULL;
47082 }
47083
47084
47085 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47086 PyObject *resultobj = 0;
47087 wxSizer *arg1 = (wxSizer *) 0 ;
47088 wxWindow *arg2 = (wxWindow *) 0 ;
47089 wxSize result;
47090 void *argp1 = 0 ;
47091 int res1 = 0 ;
47092 void *argp2 = 0 ;
47093 int res2 = 0 ;
47094 PyObject * obj0 = 0 ;
47095 PyObject * obj1 = 0 ;
47096 char * kwnames[] = {
47097 (char *) "self",(char *) "window", NULL
47098 };
47099
47100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47102 if (!SWIG_IsOK(res1)) {
47103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47104 }
47105 arg1 = reinterpret_cast< wxSizer * >(argp1);
47106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47107 if (!SWIG_IsOK(res2)) {
47108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47109 }
47110 arg2 = reinterpret_cast< wxWindow * >(argp2);
47111 {
47112 PyThreadState* __tstate = wxPyBeginAllowThreads();
47113 result = (arg1)->Fit(arg2);
47114 wxPyEndAllowThreads(__tstate);
47115 if (PyErr_Occurred()) SWIG_fail;
47116 }
47117 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47118 return resultobj;
47119 fail:
47120 return NULL;
47121 }
47122
47123
47124 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47125 PyObject *resultobj = 0;
47126 wxSizer *arg1 = (wxSizer *) 0 ;
47127 wxWindow *arg2 = (wxWindow *) 0 ;
47128 void *argp1 = 0 ;
47129 int res1 = 0 ;
47130 void *argp2 = 0 ;
47131 int res2 = 0 ;
47132 PyObject * obj0 = 0 ;
47133 PyObject * obj1 = 0 ;
47134 char * kwnames[] = {
47135 (char *) "self",(char *) "window", NULL
47136 };
47137
47138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47140 if (!SWIG_IsOK(res1)) {
47141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47142 }
47143 arg1 = reinterpret_cast< wxSizer * >(argp1);
47144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47145 if (!SWIG_IsOK(res2)) {
47146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47147 }
47148 arg2 = reinterpret_cast< wxWindow * >(argp2);
47149 {
47150 PyThreadState* __tstate = wxPyBeginAllowThreads();
47151 (arg1)->FitInside(arg2);
47152 wxPyEndAllowThreads(__tstate);
47153 if (PyErr_Occurred()) SWIG_fail;
47154 }
47155 resultobj = SWIG_Py_Void();
47156 return resultobj;
47157 fail:
47158 return NULL;
47159 }
47160
47161
47162 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47163 PyObject *resultobj = 0;
47164 wxSizer *arg1 = (wxSizer *) 0 ;
47165 wxWindow *arg2 = (wxWindow *) 0 ;
47166 void *argp1 = 0 ;
47167 int res1 = 0 ;
47168 void *argp2 = 0 ;
47169 int res2 = 0 ;
47170 PyObject * obj0 = 0 ;
47171 PyObject * obj1 = 0 ;
47172 char * kwnames[] = {
47173 (char *) "self",(char *) "window", NULL
47174 };
47175
47176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47178 if (!SWIG_IsOK(res1)) {
47179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47180 }
47181 arg1 = reinterpret_cast< wxSizer * >(argp1);
47182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47183 if (!SWIG_IsOK(res2)) {
47184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47185 }
47186 arg2 = reinterpret_cast< wxWindow * >(argp2);
47187 {
47188 PyThreadState* __tstate = wxPyBeginAllowThreads();
47189 (arg1)->SetSizeHints(arg2);
47190 wxPyEndAllowThreads(__tstate);
47191 if (PyErr_Occurred()) SWIG_fail;
47192 }
47193 resultobj = SWIG_Py_Void();
47194 return resultobj;
47195 fail:
47196 return NULL;
47197 }
47198
47199
47200 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47201 PyObject *resultobj = 0;
47202 wxSizer *arg1 = (wxSizer *) 0 ;
47203 wxWindow *arg2 = (wxWindow *) 0 ;
47204 void *argp1 = 0 ;
47205 int res1 = 0 ;
47206 void *argp2 = 0 ;
47207 int res2 = 0 ;
47208 PyObject * obj0 = 0 ;
47209 PyObject * obj1 = 0 ;
47210 char * kwnames[] = {
47211 (char *) "self",(char *) "window", NULL
47212 };
47213
47214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47216 if (!SWIG_IsOK(res1)) {
47217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47218 }
47219 arg1 = reinterpret_cast< wxSizer * >(argp1);
47220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47221 if (!SWIG_IsOK(res2)) {
47222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47223 }
47224 arg2 = reinterpret_cast< wxWindow * >(argp2);
47225 {
47226 PyThreadState* __tstate = wxPyBeginAllowThreads();
47227 (arg1)->SetVirtualSizeHints(arg2);
47228 wxPyEndAllowThreads(__tstate);
47229 if (PyErr_Occurred()) SWIG_fail;
47230 }
47231 resultobj = SWIG_Py_Void();
47232 return resultobj;
47233 fail:
47234 return NULL;
47235 }
47236
47237
47238 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47239 PyObject *resultobj = 0;
47240 wxSizer *arg1 = (wxSizer *) 0 ;
47241 bool arg2 = (bool) false ;
47242 void *argp1 = 0 ;
47243 int res1 = 0 ;
47244 bool val2 ;
47245 int ecode2 = 0 ;
47246 PyObject * obj0 = 0 ;
47247 PyObject * obj1 = 0 ;
47248 char * kwnames[] = {
47249 (char *) "self",(char *) "deleteWindows", NULL
47250 };
47251
47252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47254 if (!SWIG_IsOK(res1)) {
47255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47256 }
47257 arg1 = reinterpret_cast< wxSizer * >(argp1);
47258 if (obj1) {
47259 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47260 if (!SWIG_IsOK(ecode2)) {
47261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47262 }
47263 arg2 = static_cast< bool >(val2);
47264 }
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 (arg1)->Clear(arg2);
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 resultobj = SWIG_Py_Void();
47272 return resultobj;
47273 fail:
47274 return NULL;
47275 }
47276
47277
47278 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47279 PyObject *resultobj = 0;
47280 wxSizer *arg1 = (wxSizer *) 0 ;
47281 void *argp1 = 0 ;
47282 int res1 = 0 ;
47283 PyObject *swig_obj[1] ;
47284
47285 if (!args) SWIG_fail;
47286 swig_obj[0] = args;
47287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47288 if (!SWIG_IsOK(res1)) {
47289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47290 }
47291 arg1 = reinterpret_cast< wxSizer * >(argp1);
47292 {
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 (arg1)->DeleteWindows();
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_Py_Void();
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47306 PyObject *resultobj = 0;
47307 wxSizer *arg1 = (wxSizer *) 0 ;
47308 PyObject *result = 0 ;
47309 void *argp1 = 0 ;
47310 int res1 = 0 ;
47311 PyObject *swig_obj[1] ;
47312
47313 if (!args) SWIG_fail;
47314 swig_obj[0] = args;
47315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47316 if (!SWIG_IsOK(res1)) {
47317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47318 }
47319 arg1 = reinterpret_cast< wxSizer * >(argp1);
47320 {
47321 PyThreadState* __tstate = wxPyBeginAllowThreads();
47322 result = (PyObject *)wxSizer_GetChildren(arg1);
47323 wxPyEndAllowThreads(__tstate);
47324 if (PyErr_Occurred()) SWIG_fail;
47325 }
47326 resultobj = result;
47327 return resultobj;
47328 fail:
47329 return NULL;
47330 }
47331
47332
47333 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47334 PyObject *resultobj = 0;
47335 wxSizer *arg1 = (wxSizer *) 0 ;
47336 PyObject *arg2 = (PyObject *) 0 ;
47337 bool arg3 = (bool) true ;
47338 bool arg4 = (bool) false ;
47339 bool result;
47340 void *argp1 = 0 ;
47341 int res1 = 0 ;
47342 bool val3 ;
47343 int ecode3 = 0 ;
47344 bool val4 ;
47345 int ecode4 = 0 ;
47346 PyObject * obj0 = 0 ;
47347 PyObject * obj1 = 0 ;
47348 PyObject * obj2 = 0 ;
47349 PyObject * obj3 = 0 ;
47350 char * kwnames[] = {
47351 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47352 };
47353
47354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47356 if (!SWIG_IsOK(res1)) {
47357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47358 }
47359 arg1 = reinterpret_cast< wxSizer * >(argp1);
47360 arg2 = obj1;
47361 if (obj2) {
47362 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47363 if (!SWIG_IsOK(ecode3)) {
47364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47365 }
47366 arg3 = static_cast< bool >(val3);
47367 }
47368 if (obj3) {
47369 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47370 if (!SWIG_IsOK(ecode4)) {
47371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47372 }
47373 arg4 = static_cast< bool >(val4);
47374 }
47375 {
47376 PyThreadState* __tstate = wxPyBeginAllowThreads();
47377 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47378 wxPyEndAllowThreads(__tstate);
47379 if (PyErr_Occurred()) SWIG_fail;
47380 }
47381 {
47382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47383 }
47384 return resultobj;
47385 fail:
47386 return NULL;
47387 }
47388
47389
47390 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47391 PyObject *resultobj = 0;
47392 wxSizer *arg1 = (wxSizer *) 0 ;
47393 PyObject *arg2 = (PyObject *) 0 ;
47394 bool result;
47395 void *argp1 = 0 ;
47396 int res1 = 0 ;
47397 PyObject * obj0 = 0 ;
47398 PyObject * obj1 = 0 ;
47399 char * kwnames[] = {
47400 (char *) "self",(char *) "item", NULL
47401 };
47402
47403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47405 if (!SWIG_IsOK(res1)) {
47406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47407 }
47408 arg1 = reinterpret_cast< wxSizer * >(argp1);
47409 arg2 = obj1;
47410 {
47411 PyThreadState* __tstate = wxPyBeginAllowThreads();
47412 result = (bool)wxSizer_IsShown(arg1,arg2);
47413 wxPyEndAllowThreads(__tstate);
47414 if (PyErr_Occurred()) SWIG_fail;
47415 }
47416 {
47417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47418 }
47419 return resultobj;
47420 fail:
47421 return NULL;
47422 }
47423
47424
47425 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47426 PyObject *resultobj = 0;
47427 wxSizer *arg1 = (wxSizer *) 0 ;
47428 bool arg2 ;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 bool val2 ;
47432 int ecode2 = 0 ;
47433 PyObject * obj0 = 0 ;
47434 PyObject * obj1 = 0 ;
47435 char * kwnames[] = {
47436 (char *) "self",(char *) "show", NULL
47437 };
47438
47439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47441 if (!SWIG_IsOK(res1)) {
47442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47443 }
47444 arg1 = reinterpret_cast< wxSizer * >(argp1);
47445 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47446 if (!SWIG_IsOK(ecode2)) {
47447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47448 }
47449 arg2 = static_cast< bool >(val2);
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 (arg1)->ShowItems(arg2);
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 resultobj = SWIG_Py_Void();
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47464 PyObject *obj;
47465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47466 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47467 return SWIG_Py_Void();
47468 }
47469
47470 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47471 PyObject *resultobj = 0;
47472 wxPySizer *result = 0 ;
47473
47474 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47475 {
47476 PyThreadState* __tstate = wxPyBeginAllowThreads();
47477 result = (wxPySizer *)new wxPySizer();
47478 wxPyEndAllowThreads(__tstate);
47479 if (PyErr_Occurred()) SWIG_fail;
47480 }
47481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47482 return resultobj;
47483 fail:
47484 return NULL;
47485 }
47486
47487
47488 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47489 PyObject *resultobj = 0;
47490 wxPySizer *arg1 = (wxPySizer *) 0 ;
47491 PyObject *arg2 = (PyObject *) 0 ;
47492 PyObject *arg3 = (PyObject *) 0 ;
47493 void *argp1 = 0 ;
47494 int res1 = 0 ;
47495 PyObject * obj0 = 0 ;
47496 PyObject * obj1 = 0 ;
47497 PyObject * obj2 = 0 ;
47498 char * kwnames[] = {
47499 (char *) "self",(char *) "self",(char *) "_class", NULL
47500 };
47501
47502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47504 if (!SWIG_IsOK(res1)) {
47505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47506 }
47507 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47508 arg2 = obj1;
47509 arg3 = obj2;
47510 {
47511 PyThreadState* __tstate = wxPyBeginAllowThreads();
47512 (arg1)->_setCallbackInfo(arg2,arg3);
47513 wxPyEndAllowThreads(__tstate);
47514 if (PyErr_Occurred()) SWIG_fail;
47515 }
47516 resultobj = SWIG_Py_Void();
47517 return resultobj;
47518 fail:
47519 return NULL;
47520 }
47521
47522
47523 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47524 PyObject *obj;
47525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47526 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47527 return SWIG_Py_Void();
47528 }
47529
47530 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47531 return SWIG_Python_InitShadowInstance(args);
47532 }
47533
47534 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47535 PyObject *resultobj = 0;
47536 int arg1 = (int) wxHORIZONTAL ;
47537 wxBoxSizer *result = 0 ;
47538 int val1 ;
47539 int ecode1 = 0 ;
47540 PyObject * obj0 = 0 ;
47541 char * kwnames[] = {
47542 (char *) "orient", NULL
47543 };
47544
47545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47546 if (obj0) {
47547 ecode1 = SWIG_AsVal_int(obj0, &val1);
47548 if (!SWIG_IsOK(ecode1)) {
47549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47550 }
47551 arg1 = static_cast< int >(val1);
47552 }
47553 {
47554 PyThreadState* __tstate = wxPyBeginAllowThreads();
47555 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47556 wxPyEndAllowThreads(__tstate);
47557 if (PyErr_Occurred()) SWIG_fail;
47558 }
47559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47560 return resultobj;
47561 fail:
47562 return NULL;
47563 }
47564
47565
47566 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47567 PyObject *resultobj = 0;
47568 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47569 int result;
47570 void *argp1 = 0 ;
47571 int res1 = 0 ;
47572 PyObject *swig_obj[1] ;
47573
47574 if (!args) SWIG_fail;
47575 swig_obj[0] = args;
47576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47577 if (!SWIG_IsOK(res1)) {
47578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47579 }
47580 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47581 {
47582 PyThreadState* __tstate = wxPyBeginAllowThreads();
47583 result = (int)(arg1)->GetOrientation();
47584 wxPyEndAllowThreads(__tstate);
47585 if (PyErr_Occurred()) SWIG_fail;
47586 }
47587 resultobj = SWIG_From_int(static_cast< int >(result));
47588 return resultobj;
47589 fail:
47590 return NULL;
47591 }
47592
47593
47594 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47595 PyObject *resultobj = 0;
47596 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47597 int arg2 ;
47598 void *argp1 = 0 ;
47599 int res1 = 0 ;
47600 int val2 ;
47601 int ecode2 = 0 ;
47602 PyObject * obj0 = 0 ;
47603 PyObject * obj1 = 0 ;
47604 char * kwnames[] = {
47605 (char *) "self",(char *) "orient", NULL
47606 };
47607
47608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47610 if (!SWIG_IsOK(res1)) {
47611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47612 }
47613 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47614 ecode2 = SWIG_AsVal_int(obj1, &val2);
47615 if (!SWIG_IsOK(ecode2)) {
47616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47617 }
47618 arg2 = static_cast< int >(val2);
47619 {
47620 PyThreadState* __tstate = wxPyBeginAllowThreads();
47621 (arg1)->SetOrientation(arg2);
47622 wxPyEndAllowThreads(__tstate);
47623 if (PyErr_Occurred()) SWIG_fail;
47624 }
47625 resultobj = SWIG_Py_Void();
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47633 PyObject *obj;
47634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47635 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47636 return SWIG_Py_Void();
47637 }
47638
47639 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47640 return SWIG_Python_InitShadowInstance(args);
47641 }
47642
47643 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47646 int arg2 = (int) wxHORIZONTAL ;
47647 wxStaticBoxSizer *result = 0 ;
47648 void *argp1 = 0 ;
47649 int res1 = 0 ;
47650 int val2 ;
47651 int ecode2 = 0 ;
47652 PyObject * obj0 = 0 ;
47653 PyObject * obj1 = 0 ;
47654 char * kwnames[] = {
47655 (char *) "box",(char *) "orient", NULL
47656 };
47657
47658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47660 if (!SWIG_IsOK(res1)) {
47661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47662 }
47663 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47664 if (obj1) {
47665 ecode2 = SWIG_AsVal_int(obj1, &val2);
47666 if (!SWIG_IsOK(ecode2)) {
47667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47668 }
47669 arg2 = static_cast< int >(val2);
47670 }
47671 {
47672 PyThreadState* __tstate = wxPyBeginAllowThreads();
47673 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47674 wxPyEndAllowThreads(__tstate);
47675 if (PyErr_Occurred()) SWIG_fail;
47676 }
47677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47678 return resultobj;
47679 fail:
47680 return NULL;
47681 }
47682
47683
47684 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47685 PyObject *resultobj = 0;
47686 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47687 wxStaticBox *result = 0 ;
47688 void *argp1 = 0 ;
47689 int res1 = 0 ;
47690 PyObject *swig_obj[1] ;
47691
47692 if (!args) SWIG_fail;
47693 swig_obj[0] = args;
47694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47695 if (!SWIG_IsOK(res1)) {
47696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47697 }
47698 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47699 {
47700 PyThreadState* __tstate = wxPyBeginAllowThreads();
47701 result = (wxStaticBox *)(arg1)->GetStaticBox();
47702 wxPyEndAllowThreads(__tstate);
47703 if (PyErr_Occurred()) SWIG_fail;
47704 }
47705 {
47706 resultobj = wxPyMake_wxObject(result, (bool)0);
47707 }
47708 return resultobj;
47709 fail:
47710 return NULL;
47711 }
47712
47713
47714 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47715 PyObject *obj;
47716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47717 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47718 return SWIG_Py_Void();
47719 }
47720
47721 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47722 return SWIG_Python_InitShadowInstance(args);
47723 }
47724
47725 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47726 PyObject *resultobj = 0;
47727 int arg1 = (int) 1 ;
47728 int arg2 = (int) 0 ;
47729 int arg3 = (int) 0 ;
47730 int arg4 = (int) 0 ;
47731 wxGridSizer *result = 0 ;
47732 int val1 ;
47733 int ecode1 = 0 ;
47734 int val2 ;
47735 int ecode2 = 0 ;
47736 int val3 ;
47737 int ecode3 = 0 ;
47738 int val4 ;
47739 int ecode4 = 0 ;
47740 PyObject * obj0 = 0 ;
47741 PyObject * obj1 = 0 ;
47742 PyObject * obj2 = 0 ;
47743 PyObject * obj3 = 0 ;
47744 char * kwnames[] = {
47745 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47746 };
47747
47748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47749 if (obj0) {
47750 ecode1 = SWIG_AsVal_int(obj0, &val1);
47751 if (!SWIG_IsOK(ecode1)) {
47752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47753 }
47754 arg1 = static_cast< int >(val1);
47755 }
47756 if (obj1) {
47757 ecode2 = SWIG_AsVal_int(obj1, &val2);
47758 if (!SWIG_IsOK(ecode2)) {
47759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47760 }
47761 arg2 = static_cast< int >(val2);
47762 }
47763 if (obj2) {
47764 ecode3 = SWIG_AsVal_int(obj2, &val3);
47765 if (!SWIG_IsOK(ecode3)) {
47766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47767 }
47768 arg3 = static_cast< int >(val3);
47769 }
47770 if (obj3) {
47771 ecode4 = SWIG_AsVal_int(obj3, &val4);
47772 if (!SWIG_IsOK(ecode4)) {
47773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47774 }
47775 arg4 = static_cast< int >(val4);
47776 }
47777 {
47778 PyThreadState* __tstate = wxPyBeginAllowThreads();
47779 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47780 wxPyEndAllowThreads(__tstate);
47781 if (PyErr_Occurred()) SWIG_fail;
47782 }
47783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47784 return resultobj;
47785 fail:
47786 return NULL;
47787 }
47788
47789
47790 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47791 PyObject *resultobj = 0;
47792 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47793 int arg2 ;
47794 void *argp1 = 0 ;
47795 int res1 = 0 ;
47796 int val2 ;
47797 int ecode2 = 0 ;
47798 PyObject * obj0 = 0 ;
47799 PyObject * obj1 = 0 ;
47800 char * kwnames[] = {
47801 (char *) "self",(char *) "cols", NULL
47802 };
47803
47804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47806 if (!SWIG_IsOK(res1)) {
47807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47808 }
47809 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47810 ecode2 = SWIG_AsVal_int(obj1, &val2);
47811 if (!SWIG_IsOK(ecode2)) {
47812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47813 }
47814 arg2 = static_cast< int >(val2);
47815 {
47816 PyThreadState* __tstate = wxPyBeginAllowThreads();
47817 (arg1)->SetCols(arg2);
47818 wxPyEndAllowThreads(__tstate);
47819 if (PyErr_Occurred()) SWIG_fail;
47820 }
47821 resultobj = SWIG_Py_Void();
47822 return resultobj;
47823 fail:
47824 return NULL;
47825 }
47826
47827
47828 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47829 PyObject *resultobj = 0;
47830 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47831 int arg2 ;
47832 void *argp1 = 0 ;
47833 int res1 = 0 ;
47834 int val2 ;
47835 int ecode2 = 0 ;
47836 PyObject * obj0 = 0 ;
47837 PyObject * obj1 = 0 ;
47838 char * kwnames[] = {
47839 (char *) "self",(char *) "rows", NULL
47840 };
47841
47842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47844 if (!SWIG_IsOK(res1)) {
47845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47846 }
47847 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47848 ecode2 = SWIG_AsVal_int(obj1, &val2);
47849 if (!SWIG_IsOK(ecode2)) {
47850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47851 }
47852 arg2 = static_cast< int >(val2);
47853 {
47854 PyThreadState* __tstate = wxPyBeginAllowThreads();
47855 (arg1)->SetRows(arg2);
47856 wxPyEndAllowThreads(__tstate);
47857 if (PyErr_Occurred()) SWIG_fail;
47858 }
47859 resultobj = SWIG_Py_Void();
47860 return resultobj;
47861 fail:
47862 return NULL;
47863 }
47864
47865
47866 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47867 PyObject *resultobj = 0;
47868 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47869 int arg2 ;
47870 void *argp1 = 0 ;
47871 int res1 = 0 ;
47872 int val2 ;
47873 int ecode2 = 0 ;
47874 PyObject * obj0 = 0 ;
47875 PyObject * obj1 = 0 ;
47876 char * kwnames[] = {
47877 (char *) "self",(char *) "gap", NULL
47878 };
47879
47880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47882 if (!SWIG_IsOK(res1)) {
47883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47884 }
47885 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47886 ecode2 = SWIG_AsVal_int(obj1, &val2);
47887 if (!SWIG_IsOK(ecode2)) {
47888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47889 }
47890 arg2 = static_cast< int >(val2);
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 (arg1)->SetVGap(arg2);
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 resultobj = SWIG_Py_Void();
47898 return resultobj;
47899 fail:
47900 return NULL;
47901 }
47902
47903
47904 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47905 PyObject *resultobj = 0;
47906 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47907 int arg2 ;
47908 void *argp1 = 0 ;
47909 int res1 = 0 ;
47910 int val2 ;
47911 int ecode2 = 0 ;
47912 PyObject * obj0 = 0 ;
47913 PyObject * obj1 = 0 ;
47914 char * kwnames[] = {
47915 (char *) "self",(char *) "gap", NULL
47916 };
47917
47918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47920 if (!SWIG_IsOK(res1)) {
47921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47922 }
47923 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47924 ecode2 = SWIG_AsVal_int(obj1, &val2);
47925 if (!SWIG_IsOK(ecode2)) {
47926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47927 }
47928 arg2 = static_cast< int >(val2);
47929 {
47930 PyThreadState* __tstate = wxPyBeginAllowThreads();
47931 (arg1)->SetHGap(arg2);
47932 wxPyEndAllowThreads(__tstate);
47933 if (PyErr_Occurred()) SWIG_fail;
47934 }
47935 resultobj = SWIG_Py_Void();
47936 return resultobj;
47937 fail:
47938 return NULL;
47939 }
47940
47941
47942 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47943 PyObject *resultobj = 0;
47944 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47945 int result;
47946 void *argp1 = 0 ;
47947 int res1 = 0 ;
47948 PyObject *swig_obj[1] ;
47949
47950 if (!args) SWIG_fail;
47951 swig_obj[0] = args;
47952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47953 if (!SWIG_IsOK(res1)) {
47954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47955 }
47956 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47957 {
47958 PyThreadState* __tstate = wxPyBeginAllowThreads();
47959 result = (int)(arg1)->GetCols();
47960 wxPyEndAllowThreads(__tstate);
47961 if (PyErr_Occurred()) SWIG_fail;
47962 }
47963 resultobj = SWIG_From_int(static_cast< int >(result));
47964 return resultobj;
47965 fail:
47966 return NULL;
47967 }
47968
47969
47970 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47971 PyObject *resultobj = 0;
47972 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47973 int result;
47974 void *argp1 = 0 ;
47975 int res1 = 0 ;
47976 PyObject *swig_obj[1] ;
47977
47978 if (!args) SWIG_fail;
47979 swig_obj[0] = args;
47980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47981 if (!SWIG_IsOK(res1)) {
47982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47983 }
47984 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47985 {
47986 PyThreadState* __tstate = wxPyBeginAllowThreads();
47987 result = (int)(arg1)->GetRows();
47988 wxPyEndAllowThreads(__tstate);
47989 if (PyErr_Occurred()) SWIG_fail;
47990 }
47991 resultobj = SWIG_From_int(static_cast< int >(result));
47992 return resultobj;
47993 fail:
47994 return NULL;
47995 }
47996
47997
47998 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47999 PyObject *resultobj = 0;
48000 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48001 int result;
48002 void *argp1 = 0 ;
48003 int res1 = 0 ;
48004 PyObject *swig_obj[1] ;
48005
48006 if (!args) SWIG_fail;
48007 swig_obj[0] = args;
48008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48009 if (!SWIG_IsOK(res1)) {
48010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48011 }
48012 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48013 {
48014 PyThreadState* __tstate = wxPyBeginAllowThreads();
48015 result = (int)(arg1)->GetVGap();
48016 wxPyEndAllowThreads(__tstate);
48017 if (PyErr_Occurred()) SWIG_fail;
48018 }
48019 resultobj = SWIG_From_int(static_cast< int >(result));
48020 return resultobj;
48021 fail:
48022 return NULL;
48023 }
48024
48025
48026 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48027 PyObject *resultobj = 0;
48028 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48029 int result;
48030 void *argp1 = 0 ;
48031 int res1 = 0 ;
48032 PyObject *swig_obj[1] ;
48033
48034 if (!args) SWIG_fail;
48035 swig_obj[0] = args;
48036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48037 if (!SWIG_IsOK(res1)) {
48038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48039 }
48040 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48041 {
48042 PyThreadState* __tstate = wxPyBeginAllowThreads();
48043 result = (int)(arg1)->GetHGap();
48044 wxPyEndAllowThreads(__tstate);
48045 if (PyErr_Occurred()) SWIG_fail;
48046 }
48047 resultobj = SWIG_From_int(static_cast< int >(result));
48048 return resultobj;
48049 fail:
48050 return NULL;
48051 }
48052
48053
48054 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48055 PyObject *obj;
48056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48057 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48058 return SWIG_Py_Void();
48059 }
48060
48061 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48062 return SWIG_Python_InitShadowInstance(args);
48063 }
48064
48065 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48066 PyObject *resultobj = 0;
48067 int arg1 = (int) 1 ;
48068 int arg2 = (int) 0 ;
48069 int arg3 = (int) 0 ;
48070 int arg4 = (int) 0 ;
48071 wxFlexGridSizer *result = 0 ;
48072 int val1 ;
48073 int ecode1 = 0 ;
48074 int val2 ;
48075 int ecode2 = 0 ;
48076 int val3 ;
48077 int ecode3 = 0 ;
48078 int val4 ;
48079 int ecode4 = 0 ;
48080 PyObject * obj0 = 0 ;
48081 PyObject * obj1 = 0 ;
48082 PyObject * obj2 = 0 ;
48083 PyObject * obj3 = 0 ;
48084 char * kwnames[] = {
48085 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48086 };
48087
48088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48089 if (obj0) {
48090 ecode1 = SWIG_AsVal_int(obj0, &val1);
48091 if (!SWIG_IsOK(ecode1)) {
48092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48093 }
48094 arg1 = static_cast< int >(val1);
48095 }
48096 if (obj1) {
48097 ecode2 = SWIG_AsVal_int(obj1, &val2);
48098 if (!SWIG_IsOK(ecode2)) {
48099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48100 }
48101 arg2 = static_cast< int >(val2);
48102 }
48103 if (obj2) {
48104 ecode3 = SWIG_AsVal_int(obj2, &val3);
48105 if (!SWIG_IsOK(ecode3)) {
48106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48107 }
48108 arg3 = static_cast< int >(val3);
48109 }
48110 if (obj3) {
48111 ecode4 = SWIG_AsVal_int(obj3, &val4);
48112 if (!SWIG_IsOK(ecode4)) {
48113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48114 }
48115 arg4 = static_cast< int >(val4);
48116 }
48117 {
48118 PyThreadState* __tstate = wxPyBeginAllowThreads();
48119 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48120 wxPyEndAllowThreads(__tstate);
48121 if (PyErr_Occurred()) SWIG_fail;
48122 }
48123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48124 return resultobj;
48125 fail:
48126 return NULL;
48127 }
48128
48129
48130 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48131 PyObject *resultobj = 0;
48132 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48133 size_t arg2 ;
48134 int arg3 = (int) 0 ;
48135 void *argp1 = 0 ;
48136 int res1 = 0 ;
48137 size_t val2 ;
48138 int ecode2 = 0 ;
48139 int val3 ;
48140 int ecode3 = 0 ;
48141 PyObject * obj0 = 0 ;
48142 PyObject * obj1 = 0 ;
48143 PyObject * obj2 = 0 ;
48144 char * kwnames[] = {
48145 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48146 };
48147
48148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48150 if (!SWIG_IsOK(res1)) {
48151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48152 }
48153 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48154 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48155 if (!SWIG_IsOK(ecode2)) {
48156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48157 }
48158 arg2 = static_cast< size_t >(val2);
48159 if (obj2) {
48160 ecode3 = SWIG_AsVal_int(obj2, &val3);
48161 if (!SWIG_IsOK(ecode3)) {
48162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48163 }
48164 arg3 = static_cast< int >(val3);
48165 }
48166 {
48167 PyThreadState* __tstate = wxPyBeginAllowThreads();
48168 (arg1)->AddGrowableRow(arg2,arg3);
48169 wxPyEndAllowThreads(__tstate);
48170 if (PyErr_Occurred()) SWIG_fail;
48171 }
48172 resultobj = SWIG_Py_Void();
48173 return resultobj;
48174 fail:
48175 return NULL;
48176 }
48177
48178
48179 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48180 PyObject *resultobj = 0;
48181 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48182 size_t arg2 ;
48183 void *argp1 = 0 ;
48184 int res1 = 0 ;
48185 size_t val2 ;
48186 int ecode2 = 0 ;
48187 PyObject * obj0 = 0 ;
48188 PyObject * obj1 = 0 ;
48189 char * kwnames[] = {
48190 (char *) "self",(char *) "idx", NULL
48191 };
48192
48193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48197 }
48198 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48199 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48200 if (!SWIG_IsOK(ecode2)) {
48201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48202 }
48203 arg2 = static_cast< size_t >(val2);
48204 {
48205 PyThreadState* __tstate = wxPyBeginAllowThreads();
48206 (arg1)->RemoveGrowableRow(arg2);
48207 wxPyEndAllowThreads(__tstate);
48208 if (PyErr_Occurred()) SWIG_fail;
48209 }
48210 resultobj = SWIG_Py_Void();
48211 return resultobj;
48212 fail:
48213 return NULL;
48214 }
48215
48216
48217 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48218 PyObject *resultobj = 0;
48219 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48220 size_t arg2 ;
48221 int arg3 = (int) 0 ;
48222 void *argp1 = 0 ;
48223 int res1 = 0 ;
48224 size_t val2 ;
48225 int ecode2 = 0 ;
48226 int val3 ;
48227 int ecode3 = 0 ;
48228 PyObject * obj0 = 0 ;
48229 PyObject * obj1 = 0 ;
48230 PyObject * obj2 = 0 ;
48231 char * kwnames[] = {
48232 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48233 };
48234
48235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48237 if (!SWIG_IsOK(res1)) {
48238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48239 }
48240 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48241 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48242 if (!SWIG_IsOK(ecode2)) {
48243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48244 }
48245 arg2 = static_cast< size_t >(val2);
48246 if (obj2) {
48247 ecode3 = SWIG_AsVal_int(obj2, &val3);
48248 if (!SWIG_IsOK(ecode3)) {
48249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48250 }
48251 arg3 = static_cast< int >(val3);
48252 }
48253 {
48254 PyThreadState* __tstate = wxPyBeginAllowThreads();
48255 (arg1)->AddGrowableCol(arg2,arg3);
48256 wxPyEndAllowThreads(__tstate);
48257 if (PyErr_Occurred()) SWIG_fail;
48258 }
48259 resultobj = SWIG_Py_Void();
48260 return resultobj;
48261 fail:
48262 return NULL;
48263 }
48264
48265
48266 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48267 PyObject *resultobj = 0;
48268 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48269 size_t arg2 ;
48270 void *argp1 = 0 ;
48271 int res1 = 0 ;
48272 size_t val2 ;
48273 int ecode2 = 0 ;
48274 PyObject * obj0 = 0 ;
48275 PyObject * obj1 = 0 ;
48276 char * kwnames[] = {
48277 (char *) "self",(char *) "idx", NULL
48278 };
48279
48280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48282 if (!SWIG_IsOK(res1)) {
48283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48284 }
48285 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48286 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48287 if (!SWIG_IsOK(ecode2)) {
48288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48289 }
48290 arg2 = static_cast< size_t >(val2);
48291 {
48292 PyThreadState* __tstate = wxPyBeginAllowThreads();
48293 (arg1)->RemoveGrowableCol(arg2);
48294 wxPyEndAllowThreads(__tstate);
48295 if (PyErr_Occurred()) SWIG_fail;
48296 }
48297 resultobj = SWIG_Py_Void();
48298 return resultobj;
48299 fail:
48300 return NULL;
48301 }
48302
48303
48304 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48305 PyObject *resultobj = 0;
48306 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48307 int arg2 ;
48308 void *argp1 = 0 ;
48309 int res1 = 0 ;
48310 int val2 ;
48311 int ecode2 = 0 ;
48312 PyObject * obj0 = 0 ;
48313 PyObject * obj1 = 0 ;
48314 char * kwnames[] = {
48315 (char *) "self",(char *) "direction", NULL
48316 };
48317
48318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48320 if (!SWIG_IsOK(res1)) {
48321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48322 }
48323 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48324 ecode2 = SWIG_AsVal_int(obj1, &val2);
48325 if (!SWIG_IsOK(ecode2)) {
48326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48327 }
48328 arg2 = static_cast< int >(val2);
48329 {
48330 PyThreadState* __tstate = wxPyBeginAllowThreads();
48331 (arg1)->SetFlexibleDirection(arg2);
48332 wxPyEndAllowThreads(__tstate);
48333 if (PyErr_Occurred()) SWIG_fail;
48334 }
48335 resultobj = SWIG_Py_Void();
48336 return resultobj;
48337 fail:
48338 return NULL;
48339 }
48340
48341
48342 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48343 PyObject *resultobj = 0;
48344 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48345 int result;
48346 void *argp1 = 0 ;
48347 int res1 = 0 ;
48348 PyObject *swig_obj[1] ;
48349
48350 if (!args) SWIG_fail;
48351 swig_obj[0] = args;
48352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48353 if (!SWIG_IsOK(res1)) {
48354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48355 }
48356 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48357 {
48358 PyThreadState* __tstate = wxPyBeginAllowThreads();
48359 result = (int)(arg1)->GetFlexibleDirection();
48360 wxPyEndAllowThreads(__tstate);
48361 if (PyErr_Occurred()) SWIG_fail;
48362 }
48363 resultobj = SWIG_From_int(static_cast< int >(result));
48364 return resultobj;
48365 fail:
48366 return NULL;
48367 }
48368
48369
48370 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48371 PyObject *resultobj = 0;
48372 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48373 wxFlexSizerGrowMode arg2 ;
48374 void *argp1 = 0 ;
48375 int res1 = 0 ;
48376 int val2 ;
48377 int ecode2 = 0 ;
48378 PyObject * obj0 = 0 ;
48379 PyObject * obj1 = 0 ;
48380 char * kwnames[] = {
48381 (char *) "self",(char *) "mode", NULL
48382 };
48383
48384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48388 }
48389 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48390 ecode2 = SWIG_AsVal_int(obj1, &val2);
48391 if (!SWIG_IsOK(ecode2)) {
48392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48393 }
48394 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 (arg1)->SetNonFlexibleGrowMode(arg2);
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 resultobj = SWIG_Py_Void();
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48409 PyObject *resultobj = 0;
48410 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48411 wxFlexSizerGrowMode result;
48412 void *argp1 = 0 ;
48413 int res1 = 0 ;
48414 PyObject *swig_obj[1] ;
48415
48416 if (!args) SWIG_fail;
48417 swig_obj[0] = args;
48418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48419 if (!SWIG_IsOK(res1)) {
48420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48421 }
48422 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48423 {
48424 PyThreadState* __tstate = wxPyBeginAllowThreads();
48425 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48426 wxPyEndAllowThreads(__tstate);
48427 if (PyErr_Occurred()) SWIG_fail;
48428 }
48429 resultobj = SWIG_From_int(static_cast< int >(result));
48430 return resultobj;
48431 fail:
48432 return NULL;
48433 }
48434
48435
48436 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48437 PyObject *resultobj = 0;
48438 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48439 wxArrayInt *result = 0 ;
48440 void *argp1 = 0 ;
48441 int res1 = 0 ;
48442 PyObject *swig_obj[1] ;
48443
48444 if (!args) SWIG_fail;
48445 swig_obj[0] = args;
48446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48447 if (!SWIG_IsOK(res1)) {
48448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48449 }
48450 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48451 {
48452 PyThreadState* __tstate = wxPyBeginAllowThreads();
48453 {
48454 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48455 result = (wxArrayInt *) &_result_ref;
48456 }
48457 wxPyEndAllowThreads(__tstate);
48458 if (PyErr_Occurred()) SWIG_fail;
48459 }
48460 {
48461 resultobj = PyList_New(0);
48462 size_t idx;
48463 for (idx = 0; idx < result->GetCount(); idx += 1) {
48464 PyObject* val = PyInt_FromLong( result->Item(idx) );
48465 PyList_Append(resultobj, val);
48466 Py_DECREF(val);
48467 }
48468 }
48469 return resultobj;
48470 fail:
48471 return NULL;
48472 }
48473
48474
48475 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48476 PyObject *resultobj = 0;
48477 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48478 wxArrayInt *result = 0 ;
48479 void *argp1 = 0 ;
48480 int res1 = 0 ;
48481 PyObject *swig_obj[1] ;
48482
48483 if (!args) SWIG_fail;
48484 swig_obj[0] = args;
48485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48486 if (!SWIG_IsOK(res1)) {
48487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48488 }
48489 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48490 {
48491 PyThreadState* __tstate = wxPyBeginAllowThreads();
48492 {
48493 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48494 result = (wxArrayInt *) &_result_ref;
48495 }
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 {
48500 resultobj = PyList_New(0);
48501 size_t idx;
48502 for (idx = 0; idx < result->GetCount(); idx += 1) {
48503 PyObject* val = PyInt_FromLong( result->Item(idx) );
48504 PyList_Append(resultobj, val);
48505 Py_DECREF(val);
48506 }
48507 }
48508 return resultobj;
48509 fail:
48510 return NULL;
48511 }
48512
48513
48514 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48515 PyObject *obj;
48516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48517 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48518 return SWIG_Py_Void();
48519 }
48520
48521 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48522 return SWIG_Python_InitShadowInstance(args);
48523 }
48524
48525 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48526 PyObject *resultobj = 0;
48527 wxStdDialogButtonSizer *result = 0 ;
48528
48529 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48530 {
48531 PyThreadState* __tstate = wxPyBeginAllowThreads();
48532 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48533 wxPyEndAllowThreads(__tstate);
48534 if (PyErr_Occurred()) SWIG_fail;
48535 }
48536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48537 return resultobj;
48538 fail:
48539 return NULL;
48540 }
48541
48542
48543 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48544 PyObject *resultobj = 0;
48545 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48546 wxButton *arg2 = (wxButton *) 0 ;
48547 void *argp1 = 0 ;
48548 int res1 = 0 ;
48549 void *argp2 = 0 ;
48550 int res2 = 0 ;
48551 PyObject * obj0 = 0 ;
48552 PyObject * obj1 = 0 ;
48553 char * kwnames[] = {
48554 (char *) "self",(char *) "button", NULL
48555 };
48556
48557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48559 if (!SWIG_IsOK(res1)) {
48560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48561 }
48562 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48563 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48564 if (!SWIG_IsOK(res2)) {
48565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48566 }
48567 arg2 = reinterpret_cast< wxButton * >(argp2);
48568 {
48569 PyThreadState* __tstate = wxPyBeginAllowThreads();
48570 (arg1)->AddButton(arg2);
48571 wxPyEndAllowThreads(__tstate);
48572 if (PyErr_Occurred()) SWIG_fail;
48573 }
48574 resultobj = SWIG_Py_Void();
48575 return resultobj;
48576 fail:
48577 return NULL;
48578 }
48579
48580
48581 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48582 PyObject *resultobj = 0;
48583 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48584 void *argp1 = 0 ;
48585 int res1 = 0 ;
48586 PyObject *swig_obj[1] ;
48587
48588 if (!args) SWIG_fail;
48589 swig_obj[0] = args;
48590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48591 if (!SWIG_IsOK(res1)) {
48592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48593 }
48594 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48595 {
48596 PyThreadState* __tstate = wxPyBeginAllowThreads();
48597 (arg1)->Realize();
48598 wxPyEndAllowThreads(__tstate);
48599 if (PyErr_Occurred()) SWIG_fail;
48600 }
48601 resultobj = SWIG_Py_Void();
48602 return resultobj;
48603 fail:
48604 return NULL;
48605 }
48606
48607
48608 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48609 PyObject *resultobj = 0;
48610 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48611 wxButton *arg2 = (wxButton *) 0 ;
48612 void *argp1 = 0 ;
48613 int res1 = 0 ;
48614 void *argp2 = 0 ;
48615 int res2 = 0 ;
48616 PyObject * obj0 = 0 ;
48617 PyObject * obj1 = 0 ;
48618 char * kwnames[] = {
48619 (char *) "self",(char *) "button", NULL
48620 };
48621
48622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48624 if (!SWIG_IsOK(res1)) {
48625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48626 }
48627 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48629 if (!SWIG_IsOK(res2)) {
48630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48631 }
48632 arg2 = reinterpret_cast< wxButton * >(argp2);
48633 {
48634 PyThreadState* __tstate = wxPyBeginAllowThreads();
48635 (arg1)->SetAffirmativeButton(arg2);
48636 wxPyEndAllowThreads(__tstate);
48637 if (PyErr_Occurred()) SWIG_fail;
48638 }
48639 resultobj = SWIG_Py_Void();
48640 return resultobj;
48641 fail:
48642 return NULL;
48643 }
48644
48645
48646 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48647 PyObject *resultobj = 0;
48648 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48649 wxButton *arg2 = (wxButton *) 0 ;
48650 void *argp1 = 0 ;
48651 int res1 = 0 ;
48652 void *argp2 = 0 ;
48653 int res2 = 0 ;
48654 PyObject * obj0 = 0 ;
48655 PyObject * obj1 = 0 ;
48656 char * kwnames[] = {
48657 (char *) "self",(char *) "button", NULL
48658 };
48659
48660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48662 if (!SWIG_IsOK(res1)) {
48663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48664 }
48665 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48667 if (!SWIG_IsOK(res2)) {
48668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48669 }
48670 arg2 = reinterpret_cast< wxButton * >(argp2);
48671 {
48672 PyThreadState* __tstate = wxPyBeginAllowThreads();
48673 (arg1)->SetNegativeButton(arg2);
48674 wxPyEndAllowThreads(__tstate);
48675 if (PyErr_Occurred()) SWIG_fail;
48676 }
48677 resultobj = SWIG_Py_Void();
48678 return resultobj;
48679 fail:
48680 return NULL;
48681 }
48682
48683
48684 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48685 PyObject *resultobj = 0;
48686 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48687 wxButton *arg2 = (wxButton *) 0 ;
48688 void *argp1 = 0 ;
48689 int res1 = 0 ;
48690 void *argp2 = 0 ;
48691 int res2 = 0 ;
48692 PyObject * obj0 = 0 ;
48693 PyObject * obj1 = 0 ;
48694 char * kwnames[] = {
48695 (char *) "self",(char *) "button", NULL
48696 };
48697
48698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48700 if (!SWIG_IsOK(res1)) {
48701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48702 }
48703 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48705 if (!SWIG_IsOK(res2)) {
48706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48707 }
48708 arg2 = reinterpret_cast< wxButton * >(argp2);
48709 {
48710 PyThreadState* __tstate = wxPyBeginAllowThreads();
48711 (arg1)->SetCancelButton(arg2);
48712 wxPyEndAllowThreads(__tstate);
48713 if (PyErr_Occurred()) SWIG_fail;
48714 }
48715 resultobj = SWIG_Py_Void();
48716 return resultobj;
48717 fail:
48718 return NULL;
48719 }
48720
48721
48722 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48723 PyObject *resultobj = 0;
48724 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48725 wxButton *result = 0 ;
48726 void *argp1 = 0 ;
48727 int res1 = 0 ;
48728 PyObject *swig_obj[1] ;
48729
48730 if (!args) SWIG_fail;
48731 swig_obj[0] = args;
48732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48733 if (!SWIG_IsOK(res1)) {
48734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48735 }
48736 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48737 {
48738 PyThreadState* __tstate = wxPyBeginAllowThreads();
48739 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48740 wxPyEndAllowThreads(__tstate);
48741 if (PyErr_Occurred()) SWIG_fail;
48742 }
48743 {
48744 resultobj = wxPyMake_wxObject(result, (bool)0);
48745 }
48746 return resultobj;
48747 fail:
48748 return NULL;
48749 }
48750
48751
48752 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48753 PyObject *resultobj = 0;
48754 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48755 wxButton *result = 0 ;
48756 void *argp1 = 0 ;
48757 int res1 = 0 ;
48758 PyObject *swig_obj[1] ;
48759
48760 if (!args) SWIG_fail;
48761 swig_obj[0] = args;
48762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48763 if (!SWIG_IsOK(res1)) {
48764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48765 }
48766 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48767 {
48768 PyThreadState* __tstate = wxPyBeginAllowThreads();
48769 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48770 wxPyEndAllowThreads(__tstate);
48771 if (PyErr_Occurred()) SWIG_fail;
48772 }
48773 {
48774 resultobj = wxPyMake_wxObject(result, (bool)0);
48775 }
48776 return resultobj;
48777 fail:
48778 return NULL;
48779 }
48780
48781
48782 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48783 PyObject *resultobj = 0;
48784 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48785 wxButton *result = 0 ;
48786 void *argp1 = 0 ;
48787 int res1 = 0 ;
48788 PyObject *swig_obj[1] ;
48789
48790 if (!args) SWIG_fail;
48791 swig_obj[0] = args;
48792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48793 if (!SWIG_IsOK(res1)) {
48794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48795 }
48796 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48797 {
48798 PyThreadState* __tstate = wxPyBeginAllowThreads();
48799 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48800 wxPyEndAllowThreads(__tstate);
48801 if (PyErr_Occurred()) SWIG_fail;
48802 }
48803 {
48804 resultobj = wxPyMake_wxObject(result, (bool)0);
48805 }
48806 return resultobj;
48807 fail:
48808 return NULL;
48809 }
48810
48811
48812 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48813 PyObject *resultobj = 0;
48814 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48815 wxButton *result = 0 ;
48816 void *argp1 = 0 ;
48817 int res1 = 0 ;
48818 PyObject *swig_obj[1] ;
48819
48820 if (!args) SWIG_fail;
48821 swig_obj[0] = args;
48822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48823 if (!SWIG_IsOK(res1)) {
48824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48825 }
48826 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48827 {
48828 PyThreadState* __tstate = wxPyBeginAllowThreads();
48829 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48830 wxPyEndAllowThreads(__tstate);
48831 if (PyErr_Occurred()) SWIG_fail;
48832 }
48833 {
48834 resultobj = wxPyMake_wxObject(result, (bool)0);
48835 }
48836 return resultobj;
48837 fail:
48838 return NULL;
48839 }
48840
48841
48842 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48843 PyObject *resultobj = 0;
48844 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48845 wxButton *result = 0 ;
48846 void *argp1 = 0 ;
48847 int res1 = 0 ;
48848 PyObject *swig_obj[1] ;
48849
48850 if (!args) SWIG_fail;
48851 swig_obj[0] = args;
48852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48853 if (!SWIG_IsOK(res1)) {
48854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48855 }
48856 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48857 {
48858 PyThreadState* __tstate = wxPyBeginAllowThreads();
48859 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48860 wxPyEndAllowThreads(__tstate);
48861 if (PyErr_Occurred()) SWIG_fail;
48862 }
48863 {
48864 resultobj = wxPyMake_wxObject(result, (bool)0);
48865 }
48866 return resultobj;
48867 fail:
48868 return NULL;
48869 }
48870
48871
48872 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48873 PyObject *obj;
48874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48875 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48876 return SWIG_Py_Void();
48877 }
48878
48879 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48880 return SWIG_Python_InitShadowInstance(args);
48881 }
48882
48883 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48884 PyObject *resultobj = 0;
48885 int arg1 = (int) 0 ;
48886 int arg2 = (int) 0 ;
48887 wxGBPosition *result = 0 ;
48888 int val1 ;
48889 int ecode1 = 0 ;
48890 int val2 ;
48891 int ecode2 = 0 ;
48892 PyObject * obj0 = 0 ;
48893 PyObject * obj1 = 0 ;
48894 char * kwnames[] = {
48895 (char *) "row",(char *) "col", NULL
48896 };
48897
48898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48899 if (obj0) {
48900 ecode1 = SWIG_AsVal_int(obj0, &val1);
48901 if (!SWIG_IsOK(ecode1)) {
48902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48903 }
48904 arg1 = static_cast< int >(val1);
48905 }
48906 if (obj1) {
48907 ecode2 = SWIG_AsVal_int(obj1, &val2);
48908 if (!SWIG_IsOK(ecode2)) {
48909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48910 }
48911 arg2 = static_cast< int >(val2);
48912 }
48913 {
48914 PyThreadState* __tstate = wxPyBeginAllowThreads();
48915 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48916 wxPyEndAllowThreads(__tstate);
48917 if (PyErr_Occurred()) SWIG_fail;
48918 }
48919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48920 return resultobj;
48921 fail:
48922 return NULL;
48923 }
48924
48925
48926 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48927 PyObject *resultobj = 0;
48928 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48929 void *argp1 = 0 ;
48930 int res1 = 0 ;
48931 PyObject *swig_obj[1] ;
48932
48933 if (!args) SWIG_fail;
48934 swig_obj[0] = args;
48935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48936 if (!SWIG_IsOK(res1)) {
48937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48938 }
48939 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48940 {
48941 PyThreadState* __tstate = wxPyBeginAllowThreads();
48942 delete arg1;
48943
48944 wxPyEndAllowThreads(__tstate);
48945 if (PyErr_Occurred()) SWIG_fail;
48946 }
48947 resultobj = SWIG_Py_Void();
48948 return resultobj;
48949 fail:
48950 return NULL;
48951 }
48952
48953
48954 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48955 PyObject *resultobj = 0;
48956 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48957 int result;
48958 void *argp1 = 0 ;
48959 int res1 = 0 ;
48960 PyObject *swig_obj[1] ;
48961
48962 if (!args) SWIG_fail;
48963 swig_obj[0] = args;
48964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48965 if (!SWIG_IsOK(res1)) {
48966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48967 }
48968 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48969 {
48970 PyThreadState* __tstate = wxPyBeginAllowThreads();
48971 result = (int)((wxGBPosition const *)arg1)->GetRow();
48972 wxPyEndAllowThreads(__tstate);
48973 if (PyErr_Occurred()) SWIG_fail;
48974 }
48975 resultobj = SWIG_From_int(static_cast< int >(result));
48976 return resultobj;
48977 fail:
48978 return NULL;
48979 }
48980
48981
48982 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48983 PyObject *resultobj = 0;
48984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48985 int result;
48986 void *argp1 = 0 ;
48987 int res1 = 0 ;
48988 PyObject *swig_obj[1] ;
48989
48990 if (!args) SWIG_fail;
48991 swig_obj[0] = args;
48992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48993 if (!SWIG_IsOK(res1)) {
48994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48995 }
48996 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48997 {
48998 PyThreadState* __tstate = wxPyBeginAllowThreads();
48999 result = (int)((wxGBPosition const *)arg1)->GetCol();
49000 wxPyEndAllowThreads(__tstate);
49001 if (PyErr_Occurred()) SWIG_fail;
49002 }
49003 resultobj = SWIG_From_int(static_cast< int >(result));
49004 return resultobj;
49005 fail:
49006 return NULL;
49007 }
49008
49009
49010 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49011 PyObject *resultobj = 0;
49012 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49013 int arg2 ;
49014 void *argp1 = 0 ;
49015 int res1 = 0 ;
49016 int val2 ;
49017 int ecode2 = 0 ;
49018 PyObject * obj0 = 0 ;
49019 PyObject * obj1 = 0 ;
49020 char * kwnames[] = {
49021 (char *) "self",(char *) "row", NULL
49022 };
49023
49024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49026 if (!SWIG_IsOK(res1)) {
49027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49028 }
49029 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49030 ecode2 = SWIG_AsVal_int(obj1, &val2);
49031 if (!SWIG_IsOK(ecode2)) {
49032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49033 }
49034 arg2 = static_cast< int >(val2);
49035 {
49036 PyThreadState* __tstate = wxPyBeginAllowThreads();
49037 (arg1)->SetRow(arg2);
49038 wxPyEndAllowThreads(__tstate);
49039 if (PyErr_Occurred()) SWIG_fail;
49040 }
49041 resultobj = SWIG_Py_Void();
49042 return resultobj;
49043 fail:
49044 return NULL;
49045 }
49046
49047
49048 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49049 PyObject *resultobj = 0;
49050 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49051 int arg2 ;
49052 void *argp1 = 0 ;
49053 int res1 = 0 ;
49054 int val2 ;
49055 int ecode2 = 0 ;
49056 PyObject * obj0 = 0 ;
49057 PyObject * obj1 = 0 ;
49058 char * kwnames[] = {
49059 (char *) "self",(char *) "col", NULL
49060 };
49061
49062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49064 if (!SWIG_IsOK(res1)) {
49065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49066 }
49067 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49068 ecode2 = SWIG_AsVal_int(obj1, &val2);
49069 if (!SWIG_IsOK(ecode2)) {
49070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49071 }
49072 arg2 = static_cast< int >(val2);
49073 {
49074 PyThreadState* __tstate = wxPyBeginAllowThreads();
49075 (arg1)->SetCol(arg2);
49076 wxPyEndAllowThreads(__tstate);
49077 if (PyErr_Occurred()) SWIG_fail;
49078 }
49079 resultobj = SWIG_Py_Void();
49080 return resultobj;
49081 fail:
49082 return NULL;
49083 }
49084
49085
49086 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49087 PyObject *resultobj = 0;
49088 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49089 PyObject *arg2 = (PyObject *) 0 ;
49090 bool result;
49091 void *argp1 = 0 ;
49092 int res1 = 0 ;
49093 PyObject * obj0 = 0 ;
49094 PyObject * obj1 = 0 ;
49095 char * kwnames[] = {
49096 (char *) "self",(char *) "other", NULL
49097 };
49098
49099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49101 if (!SWIG_IsOK(res1)) {
49102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49103 }
49104 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49105 arg2 = obj1;
49106 {
49107 result = (bool)wxGBPosition___eq__(arg1,arg2);
49108 if (PyErr_Occurred()) SWIG_fail;
49109 }
49110 {
49111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49112 }
49113 return resultobj;
49114 fail:
49115 return NULL;
49116 }
49117
49118
49119 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49120 PyObject *resultobj = 0;
49121 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49122 PyObject *arg2 = (PyObject *) 0 ;
49123 bool result;
49124 void *argp1 = 0 ;
49125 int res1 = 0 ;
49126 PyObject * obj0 = 0 ;
49127 PyObject * obj1 = 0 ;
49128 char * kwnames[] = {
49129 (char *) "self",(char *) "other", NULL
49130 };
49131
49132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49136 }
49137 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49138 arg2 = obj1;
49139 {
49140 result = (bool)wxGBPosition___ne__(arg1,arg2);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 {
49144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49145 }
49146 return resultobj;
49147 fail:
49148 return NULL;
49149 }
49150
49151
49152 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49153 PyObject *resultobj = 0;
49154 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49155 int arg2 = (int) 0 ;
49156 int arg3 = (int) 0 ;
49157 void *argp1 = 0 ;
49158 int res1 = 0 ;
49159 int val2 ;
49160 int ecode2 = 0 ;
49161 int val3 ;
49162 int ecode3 = 0 ;
49163 PyObject * obj0 = 0 ;
49164 PyObject * obj1 = 0 ;
49165 PyObject * obj2 = 0 ;
49166 char * kwnames[] = {
49167 (char *) "self",(char *) "row",(char *) "col", NULL
49168 };
49169
49170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49172 if (!SWIG_IsOK(res1)) {
49173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49174 }
49175 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49176 if (obj1) {
49177 ecode2 = SWIG_AsVal_int(obj1, &val2);
49178 if (!SWIG_IsOK(ecode2)) {
49179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49180 }
49181 arg2 = static_cast< int >(val2);
49182 }
49183 if (obj2) {
49184 ecode3 = SWIG_AsVal_int(obj2, &val3);
49185 if (!SWIG_IsOK(ecode3)) {
49186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49187 }
49188 arg3 = static_cast< int >(val3);
49189 }
49190 {
49191 PyThreadState* __tstate = wxPyBeginAllowThreads();
49192 wxGBPosition_Set(arg1,arg2,arg3);
49193 wxPyEndAllowThreads(__tstate);
49194 if (PyErr_Occurred()) SWIG_fail;
49195 }
49196 resultobj = SWIG_Py_Void();
49197 return resultobj;
49198 fail:
49199 return NULL;
49200 }
49201
49202
49203 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49204 PyObject *resultobj = 0;
49205 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49206 PyObject *result = 0 ;
49207 void *argp1 = 0 ;
49208 int res1 = 0 ;
49209 PyObject *swig_obj[1] ;
49210
49211 if (!args) SWIG_fail;
49212 swig_obj[0] = args;
49213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49214 if (!SWIG_IsOK(res1)) {
49215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49216 }
49217 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49218 {
49219 PyThreadState* __tstate = wxPyBeginAllowThreads();
49220 result = (PyObject *)wxGBPosition_Get(arg1);
49221 wxPyEndAllowThreads(__tstate);
49222 if (PyErr_Occurred()) SWIG_fail;
49223 }
49224 resultobj = result;
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49232 PyObject *obj;
49233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49234 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49235 return SWIG_Py_Void();
49236 }
49237
49238 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49239 return SWIG_Python_InitShadowInstance(args);
49240 }
49241
49242 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49243 PyObject *resultobj = 0;
49244 int arg1 = (int) 1 ;
49245 int arg2 = (int) 1 ;
49246 wxGBSpan *result = 0 ;
49247 int val1 ;
49248 int ecode1 = 0 ;
49249 int val2 ;
49250 int ecode2 = 0 ;
49251 PyObject * obj0 = 0 ;
49252 PyObject * obj1 = 0 ;
49253 char * kwnames[] = {
49254 (char *) "rowspan",(char *) "colspan", NULL
49255 };
49256
49257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49258 if (obj0) {
49259 ecode1 = SWIG_AsVal_int(obj0, &val1);
49260 if (!SWIG_IsOK(ecode1)) {
49261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49262 }
49263 arg1 = static_cast< int >(val1);
49264 }
49265 if (obj1) {
49266 ecode2 = SWIG_AsVal_int(obj1, &val2);
49267 if (!SWIG_IsOK(ecode2)) {
49268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49269 }
49270 arg2 = static_cast< int >(val2);
49271 }
49272 {
49273 PyThreadState* __tstate = wxPyBeginAllowThreads();
49274 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49275 wxPyEndAllowThreads(__tstate);
49276 if (PyErr_Occurred()) SWIG_fail;
49277 }
49278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49279 return resultobj;
49280 fail:
49281 return NULL;
49282 }
49283
49284
49285 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49286 PyObject *resultobj = 0;
49287 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49288 void *argp1 = 0 ;
49289 int res1 = 0 ;
49290 PyObject *swig_obj[1] ;
49291
49292 if (!args) SWIG_fail;
49293 swig_obj[0] = args;
49294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49295 if (!SWIG_IsOK(res1)) {
49296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49297 }
49298 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49299 {
49300 PyThreadState* __tstate = wxPyBeginAllowThreads();
49301 delete arg1;
49302
49303 wxPyEndAllowThreads(__tstate);
49304 if (PyErr_Occurred()) SWIG_fail;
49305 }
49306 resultobj = SWIG_Py_Void();
49307 return resultobj;
49308 fail:
49309 return NULL;
49310 }
49311
49312
49313 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49314 PyObject *resultobj = 0;
49315 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49316 int result;
49317 void *argp1 = 0 ;
49318 int res1 = 0 ;
49319 PyObject *swig_obj[1] ;
49320
49321 if (!args) SWIG_fail;
49322 swig_obj[0] = args;
49323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49324 if (!SWIG_IsOK(res1)) {
49325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49326 }
49327 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_From_int(static_cast< int >(result));
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49344 int result;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49354 }
49355 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_From_int(static_cast< int >(result));
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49370 PyObject *resultobj = 0;
49371 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49372 int arg2 ;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 int val2 ;
49376 int ecode2 = 0 ;
49377 PyObject * obj0 = 0 ;
49378 PyObject * obj1 = 0 ;
49379 char * kwnames[] = {
49380 (char *) "self",(char *) "rowspan", NULL
49381 };
49382
49383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49387 }
49388 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49389 ecode2 = SWIG_AsVal_int(obj1, &val2);
49390 if (!SWIG_IsOK(ecode2)) {
49391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49392 }
49393 arg2 = static_cast< int >(val2);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 (arg1)->SetRowspan(arg2);
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 resultobj = SWIG_Py_Void();
49401 return resultobj;
49402 fail:
49403 return NULL;
49404 }
49405
49406
49407 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49408 PyObject *resultobj = 0;
49409 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49410 int arg2 ;
49411 void *argp1 = 0 ;
49412 int res1 = 0 ;
49413 int val2 ;
49414 int ecode2 = 0 ;
49415 PyObject * obj0 = 0 ;
49416 PyObject * obj1 = 0 ;
49417 char * kwnames[] = {
49418 (char *) "self",(char *) "colspan", NULL
49419 };
49420
49421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49423 if (!SWIG_IsOK(res1)) {
49424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49425 }
49426 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49427 ecode2 = SWIG_AsVal_int(obj1, &val2);
49428 if (!SWIG_IsOK(ecode2)) {
49429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49430 }
49431 arg2 = static_cast< int >(val2);
49432 {
49433 PyThreadState* __tstate = wxPyBeginAllowThreads();
49434 (arg1)->SetColspan(arg2);
49435 wxPyEndAllowThreads(__tstate);
49436 if (PyErr_Occurred()) SWIG_fail;
49437 }
49438 resultobj = SWIG_Py_Void();
49439 return resultobj;
49440 fail:
49441 return NULL;
49442 }
49443
49444
49445 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49446 PyObject *resultobj = 0;
49447 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49448 PyObject *arg2 = (PyObject *) 0 ;
49449 bool result;
49450 void *argp1 = 0 ;
49451 int res1 = 0 ;
49452 PyObject * obj0 = 0 ;
49453 PyObject * obj1 = 0 ;
49454 char * kwnames[] = {
49455 (char *) "self",(char *) "other", NULL
49456 };
49457
49458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49460 if (!SWIG_IsOK(res1)) {
49461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49462 }
49463 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49464 arg2 = obj1;
49465 {
49466 result = (bool)wxGBSpan___eq__(arg1,arg2);
49467 if (PyErr_Occurred()) SWIG_fail;
49468 }
49469 {
49470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49471 }
49472 return resultobj;
49473 fail:
49474 return NULL;
49475 }
49476
49477
49478 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49479 PyObject *resultobj = 0;
49480 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49481 PyObject *arg2 = (PyObject *) 0 ;
49482 bool result;
49483 void *argp1 = 0 ;
49484 int res1 = 0 ;
49485 PyObject * obj0 = 0 ;
49486 PyObject * obj1 = 0 ;
49487 char * kwnames[] = {
49488 (char *) "self",(char *) "other", NULL
49489 };
49490
49491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49493 if (!SWIG_IsOK(res1)) {
49494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49495 }
49496 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49497 arg2 = obj1;
49498 {
49499 result = (bool)wxGBSpan___ne__(arg1,arg2);
49500 if (PyErr_Occurred()) SWIG_fail;
49501 }
49502 {
49503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49504 }
49505 return resultobj;
49506 fail:
49507 return NULL;
49508 }
49509
49510
49511 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49512 PyObject *resultobj = 0;
49513 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49514 int arg2 = (int) 1 ;
49515 int arg3 = (int) 1 ;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 int val2 ;
49519 int ecode2 = 0 ;
49520 int val3 ;
49521 int ecode3 = 0 ;
49522 PyObject * obj0 = 0 ;
49523 PyObject * obj1 = 0 ;
49524 PyObject * obj2 = 0 ;
49525 char * kwnames[] = {
49526 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49527 };
49528
49529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49531 if (!SWIG_IsOK(res1)) {
49532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49533 }
49534 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49535 if (obj1) {
49536 ecode2 = SWIG_AsVal_int(obj1, &val2);
49537 if (!SWIG_IsOK(ecode2)) {
49538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49539 }
49540 arg2 = static_cast< int >(val2);
49541 }
49542 if (obj2) {
49543 ecode3 = SWIG_AsVal_int(obj2, &val3);
49544 if (!SWIG_IsOK(ecode3)) {
49545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49546 }
49547 arg3 = static_cast< int >(val3);
49548 }
49549 {
49550 PyThreadState* __tstate = wxPyBeginAllowThreads();
49551 wxGBSpan_Set(arg1,arg2,arg3);
49552 wxPyEndAllowThreads(__tstate);
49553 if (PyErr_Occurred()) SWIG_fail;
49554 }
49555 resultobj = SWIG_Py_Void();
49556 return resultobj;
49557 fail:
49558 return NULL;
49559 }
49560
49561
49562 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49563 PyObject *resultobj = 0;
49564 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49565 PyObject *result = 0 ;
49566 void *argp1 = 0 ;
49567 int res1 = 0 ;
49568 PyObject *swig_obj[1] ;
49569
49570 if (!args) SWIG_fail;
49571 swig_obj[0] = args;
49572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49573 if (!SWIG_IsOK(res1)) {
49574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49575 }
49576 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49577 {
49578 PyThreadState* __tstate = wxPyBeginAllowThreads();
49579 result = (PyObject *)wxGBSpan_Get(arg1);
49580 wxPyEndAllowThreads(__tstate);
49581 if (PyErr_Occurred()) SWIG_fail;
49582 }
49583 resultobj = result;
49584 return resultobj;
49585 fail:
49586 return NULL;
49587 }
49588
49589
49590 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49591 PyObject *obj;
49592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49593 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49594 return SWIG_Py_Void();
49595 }
49596
49597 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49598 return SWIG_Python_InitShadowInstance(args);
49599 }
49600
49601 SWIGINTERN int DefaultSpan_set(PyObject *) {
49602 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49603 return 1;
49604 }
49605
49606
49607 SWIGINTERN PyObject *DefaultSpan_get(void) {
49608 PyObject *pyobj = 0;
49609
49610 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49611 return pyobj;
49612 }
49613
49614
49615 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49616 PyObject *resultobj = 0;
49617 wxGBSizerItem *result = 0 ;
49618
49619 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49620 {
49621 PyThreadState* __tstate = wxPyBeginAllowThreads();
49622 result = (wxGBSizerItem *)new wxGBSizerItem();
49623 wxPyEndAllowThreads(__tstate);
49624 if (PyErr_Occurred()) SWIG_fail;
49625 }
49626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49627 return resultobj;
49628 fail:
49629 return NULL;
49630 }
49631
49632
49633 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49634 PyObject *resultobj = 0;
49635 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49636 void *argp1 = 0 ;
49637 int res1 = 0 ;
49638 PyObject *swig_obj[1] ;
49639
49640 if (!args) SWIG_fail;
49641 swig_obj[0] = args;
49642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49643 if (!SWIG_IsOK(res1)) {
49644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49645 }
49646 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49647 {
49648 PyThreadState* __tstate = wxPyBeginAllowThreads();
49649 delete arg1;
49650
49651 wxPyEndAllowThreads(__tstate);
49652 if (PyErr_Occurred()) SWIG_fail;
49653 }
49654 resultobj = SWIG_Py_Void();
49655 return resultobj;
49656 fail:
49657 return NULL;
49658 }
49659
49660
49661 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49662 PyObject *resultobj = 0;
49663 wxWindow *arg1 = (wxWindow *) 0 ;
49664 wxGBPosition *arg2 = 0 ;
49665 wxGBSpan *arg3 = 0 ;
49666 int arg4 ;
49667 int arg5 ;
49668 PyObject *arg6 = (PyObject *) NULL ;
49669 wxGBSizerItem *result = 0 ;
49670 void *argp1 = 0 ;
49671 int res1 = 0 ;
49672 wxGBPosition temp2 ;
49673 wxGBSpan temp3 ;
49674 int val4 ;
49675 int ecode4 = 0 ;
49676 int val5 ;
49677 int ecode5 = 0 ;
49678 PyObject * obj0 = 0 ;
49679 PyObject * obj1 = 0 ;
49680 PyObject * obj2 = 0 ;
49681 PyObject * obj3 = 0 ;
49682 PyObject * obj4 = 0 ;
49683 PyObject * obj5 = 0 ;
49684 char * kwnames[] = {
49685 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49686 };
49687
49688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49690 if (!SWIG_IsOK(res1)) {
49691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49692 }
49693 arg1 = reinterpret_cast< wxWindow * >(argp1);
49694 {
49695 arg2 = &temp2;
49696 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49697 }
49698 {
49699 arg3 = &temp3;
49700 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49701 }
49702 ecode4 = SWIG_AsVal_int(obj3, &val4);
49703 if (!SWIG_IsOK(ecode4)) {
49704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49705 }
49706 arg4 = static_cast< int >(val4);
49707 ecode5 = SWIG_AsVal_int(obj4, &val5);
49708 if (!SWIG_IsOK(ecode5)) {
49709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49710 }
49711 arg5 = static_cast< int >(val5);
49712 if (obj5) {
49713 arg6 = obj5;
49714 }
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxSizer *arg1 = (wxSizer *) 0 ;
49731 wxGBPosition *arg2 = 0 ;
49732 wxGBSpan *arg3 = 0 ;
49733 int arg4 ;
49734 int arg5 ;
49735 PyObject *arg6 = (PyObject *) NULL ;
49736 wxGBSizerItem *result = 0 ;
49737 int res1 = 0 ;
49738 wxGBPosition temp2 ;
49739 wxGBSpan temp3 ;
49740 int val4 ;
49741 int ecode4 = 0 ;
49742 int val5 ;
49743 int ecode5 = 0 ;
49744 PyObject * obj0 = 0 ;
49745 PyObject * obj1 = 0 ;
49746 PyObject * obj2 = 0 ;
49747 PyObject * obj3 = 0 ;
49748 PyObject * obj4 = 0 ;
49749 PyObject * obj5 = 0 ;
49750 char * kwnames[] = {
49751 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49752 };
49753
49754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49755 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49756 if (!SWIG_IsOK(res1)) {
49757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49758 }
49759 {
49760 arg2 = &temp2;
49761 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49762 }
49763 {
49764 arg3 = &temp3;
49765 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49766 }
49767 ecode4 = SWIG_AsVal_int(obj3, &val4);
49768 if (!SWIG_IsOK(ecode4)) {
49769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49770 }
49771 arg4 = static_cast< int >(val4);
49772 ecode5 = SWIG_AsVal_int(obj4, &val5);
49773 if (!SWIG_IsOK(ecode5)) {
49774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49775 }
49776 arg5 = static_cast< int >(val5);
49777 if (obj5) {
49778 arg6 = obj5;
49779 }
49780 {
49781 PyThreadState* __tstate = wxPyBeginAllowThreads();
49782 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49783 wxPyEndAllowThreads(__tstate);
49784 if (PyErr_Occurred()) SWIG_fail;
49785 }
49786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49787 return resultobj;
49788 fail:
49789 return NULL;
49790 }
49791
49792
49793 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49794 PyObject *resultobj = 0;
49795 int arg1 ;
49796 int arg2 ;
49797 wxGBPosition *arg3 = 0 ;
49798 wxGBSpan *arg4 = 0 ;
49799 int arg5 ;
49800 int arg6 ;
49801 PyObject *arg7 = (PyObject *) NULL ;
49802 wxGBSizerItem *result = 0 ;
49803 int val1 ;
49804 int ecode1 = 0 ;
49805 int val2 ;
49806 int ecode2 = 0 ;
49807 wxGBPosition temp3 ;
49808 wxGBSpan temp4 ;
49809 int val5 ;
49810 int ecode5 = 0 ;
49811 int val6 ;
49812 int ecode6 = 0 ;
49813 PyObject * obj0 = 0 ;
49814 PyObject * obj1 = 0 ;
49815 PyObject * obj2 = 0 ;
49816 PyObject * obj3 = 0 ;
49817 PyObject * obj4 = 0 ;
49818 PyObject * obj5 = 0 ;
49819 PyObject * obj6 = 0 ;
49820 char * kwnames[] = {
49821 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49822 };
49823
49824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49825 ecode1 = SWIG_AsVal_int(obj0, &val1);
49826 if (!SWIG_IsOK(ecode1)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49828 }
49829 arg1 = static_cast< int >(val1);
49830 ecode2 = SWIG_AsVal_int(obj1, &val2);
49831 if (!SWIG_IsOK(ecode2)) {
49832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49833 }
49834 arg2 = static_cast< int >(val2);
49835 {
49836 arg3 = &temp3;
49837 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49838 }
49839 {
49840 arg4 = &temp4;
49841 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49842 }
49843 ecode5 = SWIG_AsVal_int(obj4, &val5);
49844 if (!SWIG_IsOK(ecode5)) {
49845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49846 }
49847 arg5 = static_cast< int >(val5);
49848 ecode6 = SWIG_AsVal_int(obj5, &val6);
49849 if (!SWIG_IsOK(ecode6)) {
49850 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49851 }
49852 arg6 = static_cast< int >(val6);
49853 if (obj6) {
49854 arg7 = obj6;
49855 }
49856 {
49857 PyThreadState* __tstate = wxPyBeginAllowThreads();
49858 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49859 wxPyEndAllowThreads(__tstate);
49860 if (PyErr_Occurred()) SWIG_fail;
49861 }
49862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49863 return resultobj;
49864 fail:
49865 return NULL;
49866 }
49867
49868
49869 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49870 PyObject *resultobj = 0;
49871 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49872 wxGBPosition result;
49873 void *argp1 = 0 ;
49874 int res1 = 0 ;
49875 PyObject *swig_obj[1] ;
49876
49877 if (!args) SWIG_fail;
49878 swig_obj[0] = args;
49879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49880 if (!SWIG_IsOK(res1)) {
49881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49882 }
49883 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 result = ((wxGBSizerItem const *)arg1)->GetPos();
49887 wxPyEndAllowThreads(__tstate);
49888 if (PyErr_Occurred()) SWIG_fail;
49889 }
49890 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49898 PyObject *resultobj = 0;
49899 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49900 wxGBSpan result;
49901 void *argp1 = 0 ;
49902 int res1 = 0 ;
49903 PyObject *swig_obj[1] ;
49904
49905 if (!args) SWIG_fail;
49906 swig_obj[0] = args;
49907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49908 if (!SWIG_IsOK(res1)) {
49909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49910 }
49911 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49912 {
49913 PyThreadState* __tstate = wxPyBeginAllowThreads();
49914 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49915 wxPyEndAllowThreads(__tstate);
49916 if (PyErr_Occurred()) SWIG_fail;
49917 }
49918 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49919 return resultobj;
49920 fail:
49921 return NULL;
49922 }
49923
49924
49925 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49926 PyObject *resultobj = 0;
49927 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49928 wxGBPosition *arg2 = 0 ;
49929 bool result;
49930 void *argp1 = 0 ;
49931 int res1 = 0 ;
49932 wxGBPosition temp2 ;
49933 PyObject * obj0 = 0 ;
49934 PyObject * obj1 = 0 ;
49935 char * kwnames[] = {
49936 (char *) "self",(char *) "pos", NULL
49937 };
49938
49939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49941 if (!SWIG_IsOK(res1)) {
49942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49943 }
49944 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49945 {
49946 arg2 = &temp2;
49947 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49948 }
49949 {
49950 PyThreadState* __tstate = wxPyBeginAllowThreads();
49951 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49952 wxPyEndAllowThreads(__tstate);
49953 if (PyErr_Occurred()) SWIG_fail;
49954 }
49955 {
49956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49957 }
49958 return resultobj;
49959 fail:
49960 return NULL;
49961 }
49962
49963
49964 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49965 PyObject *resultobj = 0;
49966 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49967 wxGBSpan *arg2 = 0 ;
49968 bool result;
49969 void *argp1 = 0 ;
49970 int res1 = 0 ;
49971 wxGBSpan temp2 ;
49972 PyObject * obj0 = 0 ;
49973 PyObject * obj1 = 0 ;
49974 char * kwnames[] = {
49975 (char *) "self",(char *) "span", NULL
49976 };
49977
49978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49980 if (!SWIG_IsOK(res1)) {
49981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49982 }
49983 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49984 {
49985 arg2 = &temp2;
49986 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49987 }
49988 {
49989 PyThreadState* __tstate = wxPyBeginAllowThreads();
49990 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49991 wxPyEndAllowThreads(__tstate);
49992 if (PyErr_Occurred()) SWIG_fail;
49993 }
49994 {
49995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49996 }
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50004 PyObject *resultobj = 0;
50005 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50006 wxGBSizerItem *arg2 = 0 ;
50007 bool result;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 void *argp2 = 0 ;
50011 int res2 = 0 ;
50012 PyObject * obj0 = 0 ;
50013 PyObject * obj1 = 0 ;
50014 char * kwnames[] = {
50015 (char *) "self",(char *) "other", NULL
50016 };
50017
50018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50020 if (!SWIG_IsOK(res1)) {
50021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50022 }
50023 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50025 if (!SWIG_IsOK(res2)) {
50026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50027 }
50028 if (!argp2) {
50029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50030 }
50031 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50035 wxPyEndAllowThreads(__tstate);
50036 if (PyErr_Occurred()) SWIG_fail;
50037 }
50038 {
50039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50040 }
50041 return resultobj;
50042 fail:
50043 return NULL;
50044 }
50045
50046
50047 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50048 PyObject *resultobj = 0;
50049 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50050 wxGBPosition *arg2 = 0 ;
50051 wxGBSpan *arg3 = 0 ;
50052 bool result;
50053 void *argp1 = 0 ;
50054 int res1 = 0 ;
50055 wxGBPosition temp2 ;
50056 wxGBSpan temp3 ;
50057 PyObject * obj0 = 0 ;
50058 PyObject * obj1 = 0 ;
50059 PyObject * obj2 = 0 ;
50060 char * kwnames[] = {
50061 (char *) "self",(char *) "pos",(char *) "span", NULL
50062 };
50063
50064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50066 if (!SWIG_IsOK(res1)) {
50067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50068 }
50069 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50070 {
50071 arg2 = &temp2;
50072 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50073 }
50074 {
50075 arg3 = &temp3;
50076 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50077 }
50078 {
50079 PyThreadState* __tstate = wxPyBeginAllowThreads();
50080 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50081 wxPyEndAllowThreads(__tstate);
50082 if (PyErr_Occurred()) SWIG_fail;
50083 }
50084 {
50085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50086 }
50087 return resultobj;
50088 fail:
50089 return NULL;
50090 }
50091
50092
50093 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50094 PyObject *resultobj = 0;
50095 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50096 wxGBPosition result;
50097 void *argp1 = 0 ;
50098 int res1 = 0 ;
50099 PyObject *swig_obj[1] ;
50100
50101 if (!args) SWIG_fail;
50102 swig_obj[0] = args;
50103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50104 if (!SWIG_IsOK(res1)) {
50105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50106 }
50107 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50108 {
50109 PyThreadState* __tstate = wxPyBeginAllowThreads();
50110 result = wxGBSizerItem_GetEndPos(arg1);
50111 wxPyEndAllowThreads(__tstate);
50112 if (PyErr_Occurred()) SWIG_fail;
50113 }
50114 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50115 return resultobj;
50116 fail:
50117 return NULL;
50118 }
50119
50120
50121 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50122 PyObject *resultobj = 0;
50123 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50124 wxGridBagSizer *result = 0 ;
50125 void *argp1 = 0 ;
50126 int res1 = 0 ;
50127 PyObject *swig_obj[1] ;
50128
50129 if (!args) SWIG_fail;
50130 swig_obj[0] = args;
50131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50132 if (!SWIG_IsOK(res1)) {
50133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50134 }
50135 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50136 {
50137 PyThreadState* __tstate = wxPyBeginAllowThreads();
50138 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50139 wxPyEndAllowThreads(__tstate);
50140 if (PyErr_Occurred()) SWIG_fail;
50141 }
50142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50143 return resultobj;
50144 fail:
50145 return NULL;
50146 }
50147
50148
50149 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50150 PyObject *resultobj = 0;
50151 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50152 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50153 void *argp1 = 0 ;
50154 int res1 = 0 ;
50155 void *argp2 = 0 ;
50156 int res2 = 0 ;
50157 PyObject * obj0 = 0 ;
50158 PyObject * obj1 = 0 ;
50159 char * kwnames[] = {
50160 (char *) "self",(char *) "sizer", NULL
50161 };
50162
50163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50165 if (!SWIG_IsOK(res1)) {
50166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50167 }
50168 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50170 if (!SWIG_IsOK(res2)) {
50171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50172 }
50173 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50174 {
50175 PyThreadState* __tstate = wxPyBeginAllowThreads();
50176 (arg1)->SetGBSizer(arg2);
50177 wxPyEndAllowThreads(__tstate);
50178 if (PyErr_Occurred()) SWIG_fail;
50179 }
50180 resultobj = SWIG_Py_Void();
50181 return resultobj;
50182 fail:
50183 return NULL;
50184 }
50185
50186
50187 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50188 PyObject *obj;
50189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50190 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50191 return SWIG_Py_Void();
50192 }
50193
50194 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50195 return SWIG_Python_InitShadowInstance(args);
50196 }
50197
50198 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50199 PyObject *resultobj = 0;
50200 int arg1 = (int) 0 ;
50201 int arg2 = (int) 0 ;
50202 wxGridBagSizer *result = 0 ;
50203 int val1 ;
50204 int ecode1 = 0 ;
50205 int val2 ;
50206 int ecode2 = 0 ;
50207 PyObject * obj0 = 0 ;
50208 PyObject * obj1 = 0 ;
50209 char * kwnames[] = {
50210 (char *) "vgap",(char *) "hgap", NULL
50211 };
50212
50213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50214 if (obj0) {
50215 ecode1 = SWIG_AsVal_int(obj0, &val1);
50216 if (!SWIG_IsOK(ecode1)) {
50217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50218 }
50219 arg1 = static_cast< int >(val1);
50220 }
50221 if (obj1) {
50222 ecode2 = SWIG_AsVal_int(obj1, &val2);
50223 if (!SWIG_IsOK(ecode2)) {
50224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50225 }
50226 arg2 = static_cast< int >(val2);
50227 }
50228 {
50229 PyThreadState* __tstate = wxPyBeginAllowThreads();
50230 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50231 wxPyEndAllowThreads(__tstate);
50232 if (PyErr_Occurred()) SWIG_fail;
50233 }
50234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50235 return resultobj;
50236 fail:
50237 return NULL;
50238 }
50239
50240
50241 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50242 PyObject *resultobj = 0;
50243 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50244 PyObject *arg2 = (PyObject *) 0 ;
50245 wxGBPosition *arg3 = 0 ;
50246 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50247 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50248 int arg5 = (int) 0 ;
50249 int arg6 = (int) 0 ;
50250 PyObject *arg7 = (PyObject *) NULL ;
50251 wxGBSizerItem *result = 0 ;
50252 void *argp1 = 0 ;
50253 int res1 = 0 ;
50254 wxGBPosition temp3 ;
50255 wxGBSpan temp4 ;
50256 int val5 ;
50257 int ecode5 = 0 ;
50258 int val6 ;
50259 int ecode6 = 0 ;
50260 PyObject * obj0 = 0 ;
50261 PyObject * obj1 = 0 ;
50262 PyObject * obj2 = 0 ;
50263 PyObject * obj3 = 0 ;
50264 PyObject * obj4 = 0 ;
50265 PyObject * obj5 = 0 ;
50266 PyObject * obj6 = 0 ;
50267 char * kwnames[] = {
50268 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50269 };
50270
50271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50273 if (!SWIG_IsOK(res1)) {
50274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50275 }
50276 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50277 arg2 = obj1;
50278 {
50279 arg3 = &temp3;
50280 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50281 }
50282 if (obj3) {
50283 {
50284 arg4 = &temp4;
50285 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50286 }
50287 }
50288 if (obj4) {
50289 ecode5 = SWIG_AsVal_int(obj4, &val5);
50290 if (!SWIG_IsOK(ecode5)) {
50291 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50292 }
50293 arg5 = static_cast< int >(val5);
50294 }
50295 if (obj5) {
50296 ecode6 = SWIG_AsVal_int(obj5, &val6);
50297 if (!SWIG_IsOK(ecode6)) {
50298 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50299 }
50300 arg6 = static_cast< int >(val6);
50301 }
50302 if (obj6) {
50303 arg7 = obj6;
50304 }
50305 {
50306 PyThreadState* __tstate = wxPyBeginAllowThreads();
50307 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50308 wxPyEndAllowThreads(__tstate);
50309 if (PyErr_Occurred()) SWIG_fail;
50310 }
50311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50312 return resultobj;
50313 fail:
50314 return NULL;
50315 }
50316
50317
50318 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50319 PyObject *resultobj = 0;
50320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50321 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50322 wxGBSizerItem *result = 0 ;
50323 void *argp1 = 0 ;
50324 int res1 = 0 ;
50325 int res2 = 0 ;
50326 PyObject * obj0 = 0 ;
50327 PyObject * obj1 = 0 ;
50328 char * kwnames[] = {
50329 (char *) "self",(char *) "item", NULL
50330 };
50331
50332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50334 if (!SWIG_IsOK(res1)) {
50335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50336 }
50337 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50338 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50339 if (!SWIG_IsOK(res2)) {
50340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50341 }
50342 {
50343 PyThreadState* __tstate = wxPyBeginAllowThreads();
50344 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50345 wxPyEndAllowThreads(__tstate);
50346 if (PyErr_Occurred()) SWIG_fail;
50347 }
50348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50349 return resultobj;
50350 fail:
50351 return NULL;
50352 }
50353
50354
50355 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50356 PyObject *resultobj = 0;
50357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50358 int arg2 ;
50359 int arg3 ;
50360 wxSize result;
50361 void *argp1 = 0 ;
50362 int res1 = 0 ;
50363 int val2 ;
50364 int ecode2 = 0 ;
50365 int val3 ;
50366 int ecode3 = 0 ;
50367 PyObject * obj0 = 0 ;
50368 PyObject * obj1 = 0 ;
50369 PyObject * obj2 = 0 ;
50370 char * kwnames[] = {
50371 (char *) "self",(char *) "row",(char *) "col", NULL
50372 };
50373
50374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50376 if (!SWIG_IsOK(res1)) {
50377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50378 }
50379 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50380 ecode2 = SWIG_AsVal_int(obj1, &val2);
50381 if (!SWIG_IsOK(ecode2)) {
50382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50383 }
50384 arg2 = static_cast< int >(val2);
50385 ecode3 = SWIG_AsVal_int(obj2, &val3);
50386 if (!SWIG_IsOK(ecode3)) {
50387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50388 }
50389 arg3 = static_cast< int >(val3);
50390 {
50391 PyThreadState* __tstate = wxPyBeginAllowThreads();
50392 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50393 wxPyEndAllowThreads(__tstate);
50394 if (PyErr_Occurred()) SWIG_fail;
50395 }
50396 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50397 return resultobj;
50398 fail:
50399 return NULL;
50400 }
50401
50402
50403 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50404 PyObject *resultobj = 0;
50405 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50406 wxSize result;
50407 void *argp1 = 0 ;
50408 int res1 = 0 ;
50409 PyObject *swig_obj[1] ;
50410
50411 if (!args) SWIG_fail;
50412 swig_obj[0] = args;
50413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50414 if (!SWIG_IsOK(res1)) {
50415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50416 }
50417 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50418 {
50419 PyThreadState* __tstate = wxPyBeginAllowThreads();
50420 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50421 wxPyEndAllowThreads(__tstate);
50422 if (PyErr_Occurred()) SWIG_fail;
50423 }
50424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50425 return resultobj;
50426 fail:
50427 return NULL;
50428 }
50429
50430
50431 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50432 PyObject *resultobj = 0;
50433 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50434 wxSize *arg2 = 0 ;
50435 void *argp1 = 0 ;
50436 int res1 = 0 ;
50437 wxSize temp2 ;
50438 PyObject * obj0 = 0 ;
50439 PyObject * obj1 = 0 ;
50440 char * kwnames[] = {
50441 (char *) "self",(char *) "sz", NULL
50442 };
50443
50444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50446 if (!SWIG_IsOK(res1)) {
50447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50448 }
50449 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50450 {
50451 arg2 = &temp2;
50452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50453 }
50454 {
50455 PyThreadState* __tstate = wxPyBeginAllowThreads();
50456 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50457 wxPyEndAllowThreads(__tstate);
50458 if (PyErr_Occurred()) SWIG_fail;
50459 }
50460 resultobj = SWIG_Py_Void();
50461 return resultobj;
50462 fail:
50463 return NULL;
50464 }
50465
50466
50467 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50468 PyObject *resultobj = 0;
50469 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50470 wxWindow *arg2 = (wxWindow *) 0 ;
50471 wxGBPosition result;
50472 void *argp1 = 0 ;
50473 int res1 = 0 ;
50474 void *argp2 = 0 ;
50475 int res2 = 0 ;
50476
50477 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50479 if (!SWIG_IsOK(res1)) {
50480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50481 }
50482 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50483 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50484 if (!SWIG_IsOK(res2)) {
50485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50486 }
50487 arg2 = reinterpret_cast< wxWindow * >(argp2);
50488 {
50489 PyThreadState* __tstate = wxPyBeginAllowThreads();
50490 result = (arg1)->GetItemPosition(arg2);
50491 wxPyEndAllowThreads(__tstate);
50492 if (PyErr_Occurred()) SWIG_fail;
50493 }
50494 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50502 PyObject *resultobj = 0;
50503 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50504 wxSizer *arg2 = (wxSizer *) 0 ;
50505 wxGBPosition result;
50506 void *argp1 = 0 ;
50507 int res1 = 0 ;
50508 void *argp2 = 0 ;
50509 int res2 = 0 ;
50510
50511 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50513 if (!SWIG_IsOK(res1)) {
50514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50515 }
50516 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50518 if (!SWIG_IsOK(res2)) {
50519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50520 }
50521 arg2 = reinterpret_cast< wxSizer * >(argp2);
50522 {
50523 PyThreadState* __tstate = wxPyBeginAllowThreads();
50524 result = (arg1)->GetItemPosition(arg2);
50525 wxPyEndAllowThreads(__tstate);
50526 if (PyErr_Occurred()) SWIG_fail;
50527 }
50528 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50529 return resultobj;
50530 fail:
50531 return NULL;
50532 }
50533
50534
50535 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50536 PyObject *resultobj = 0;
50537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50538 size_t arg2 ;
50539 wxGBPosition result;
50540 void *argp1 = 0 ;
50541 int res1 = 0 ;
50542 size_t val2 ;
50543 int ecode2 = 0 ;
50544
50545 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50547 if (!SWIG_IsOK(res1)) {
50548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50549 }
50550 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50551 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50552 if (!SWIG_IsOK(ecode2)) {
50553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50554 }
50555 arg2 = static_cast< size_t >(val2);
50556 {
50557 PyThreadState* __tstate = wxPyBeginAllowThreads();
50558 result = (arg1)->GetItemPosition(arg2);
50559 wxPyEndAllowThreads(__tstate);
50560 if (PyErr_Occurred()) SWIG_fail;
50561 }
50562 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50563 return resultobj;
50564 fail:
50565 return NULL;
50566 }
50567
50568
50569 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50570 int argc;
50571 PyObject *argv[3];
50572
50573 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50574 --argc;
50575 if (argc == 2) {
50576 int _v = 0;
50577 {
50578 void *vptr = 0;
50579 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50580 _v = SWIG_CheckState(res);
50581 }
50582 if (!_v) goto check_1;
50583 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50584 }
50585 check_1:
50586
50587 if (argc == 2) {
50588 int _v = 0;
50589 {
50590 void *vptr = 0;
50591 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50592 _v = SWIG_CheckState(res);
50593 }
50594 if (!_v) goto check_2;
50595 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50596 }
50597 check_2:
50598
50599 if (argc == 2) {
50600 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50601 }
50602
50603 fail:
50604 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50605 return NULL;
50606 }
50607
50608
50609 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50610 PyObject *resultobj = 0;
50611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50612 wxWindow *arg2 = (wxWindow *) 0 ;
50613 wxGBPosition *arg3 = 0 ;
50614 bool result;
50615 void *argp1 = 0 ;
50616 int res1 = 0 ;
50617 void *argp2 = 0 ;
50618 int res2 = 0 ;
50619 wxGBPosition temp3 ;
50620
50621 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50623 if (!SWIG_IsOK(res1)) {
50624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50625 }
50626 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50627 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50628 if (!SWIG_IsOK(res2)) {
50629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50630 }
50631 arg2 = reinterpret_cast< wxWindow * >(argp2);
50632 {
50633 arg3 = &temp3;
50634 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50635 }
50636 {
50637 PyThreadState* __tstate = wxPyBeginAllowThreads();
50638 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50639 wxPyEndAllowThreads(__tstate);
50640 if (PyErr_Occurred()) SWIG_fail;
50641 }
50642 {
50643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50644 }
50645 return resultobj;
50646 fail:
50647 return NULL;
50648 }
50649
50650
50651 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50652 PyObject *resultobj = 0;
50653 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50654 wxSizer *arg2 = (wxSizer *) 0 ;
50655 wxGBPosition *arg3 = 0 ;
50656 bool result;
50657 void *argp1 = 0 ;
50658 int res1 = 0 ;
50659 void *argp2 = 0 ;
50660 int res2 = 0 ;
50661 wxGBPosition temp3 ;
50662
50663 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50665 if (!SWIG_IsOK(res1)) {
50666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50667 }
50668 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50669 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50670 if (!SWIG_IsOK(res2)) {
50671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50672 }
50673 arg2 = reinterpret_cast< wxSizer * >(argp2);
50674 {
50675 arg3 = &temp3;
50676 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50677 }
50678 {
50679 PyThreadState* __tstate = wxPyBeginAllowThreads();
50680 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50681 wxPyEndAllowThreads(__tstate);
50682 if (PyErr_Occurred()) SWIG_fail;
50683 }
50684 {
50685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50686 }
50687 return resultobj;
50688 fail:
50689 return NULL;
50690 }
50691
50692
50693 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50694 PyObject *resultobj = 0;
50695 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50696 size_t arg2 ;
50697 wxGBPosition *arg3 = 0 ;
50698 bool result;
50699 void *argp1 = 0 ;
50700 int res1 = 0 ;
50701 size_t val2 ;
50702 int ecode2 = 0 ;
50703 wxGBPosition temp3 ;
50704
50705 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50707 if (!SWIG_IsOK(res1)) {
50708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50709 }
50710 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50711 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50712 if (!SWIG_IsOK(ecode2)) {
50713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50714 }
50715 arg2 = static_cast< size_t >(val2);
50716 {
50717 arg3 = &temp3;
50718 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50719 }
50720 {
50721 PyThreadState* __tstate = wxPyBeginAllowThreads();
50722 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50723 wxPyEndAllowThreads(__tstate);
50724 if (PyErr_Occurred()) SWIG_fail;
50725 }
50726 {
50727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50728 }
50729 return resultobj;
50730 fail:
50731 return NULL;
50732 }
50733
50734
50735 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50736 int argc;
50737 PyObject *argv[4];
50738
50739 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50740 --argc;
50741 if (argc == 3) {
50742 int _v = 0;
50743 {
50744 void *vptr = 0;
50745 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50746 _v = SWIG_CheckState(res);
50747 }
50748 if (!_v) goto check_1;
50749 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50750 }
50751 check_1:
50752
50753 if (argc == 3) {
50754 int _v = 0;
50755 {
50756 void *vptr = 0;
50757 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50758 _v = SWIG_CheckState(res);
50759 }
50760 if (!_v) goto check_2;
50761 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50762 }
50763 check_2:
50764
50765 if (argc == 3) {
50766 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50767 }
50768
50769 fail:
50770 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50771 return NULL;
50772 }
50773
50774
50775 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50776 PyObject *resultobj = 0;
50777 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50778 wxWindow *arg2 = (wxWindow *) 0 ;
50779 wxGBSpan result;
50780 void *argp1 = 0 ;
50781 int res1 = 0 ;
50782 void *argp2 = 0 ;
50783 int res2 = 0 ;
50784
50785 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50787 if (!SWIG_IsOK(res1)) {
50788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50789 }
50790 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50791 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50792 if (!SWIG_IsOK(res2)) {
50793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50794 }
50795 arg2 = reinterpret_cast< wxWindow * >(argp2);
50796 {
50797 PyThreadState* __tstate = wxPyBeginAllowThreads();
50798 result = (arg1)->GetItemSpan(arg2);
50799 wxPyEndAllowThreads(__tstate);
50800 if (PyErr_Occurred()) SWIG_fail;
50801 }
50802 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50803 return resultobj;
50804 fail:
50805 return NULL;
50806 }
50807
50808
50809 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50810 PyObject *resultobj = 0;
50811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50812 wxSizer *arg2 = (wxSizer *) 0 ;
50813 wxGBSpan result;
50814 void *argp1 = 0 ;
50815 int res1 = 0 ;
50816 void *argp2 = 0 ;
50817 int res2 = 0 ;
50818
50819 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50821 if (!SWIG_IsOK(res1)) {
50822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50823 }
50824 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50825 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50826 if (!SWIG_IsOK(res2)) {
50827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50828 }
50829 arg2 = reinterpret_cast< wxSizer * >(argp2);
50830 {
50831 PyThreadState* __tstate = wxPyBeginAllowThreads();
50832 result = (arg1)->GetItemSpan(arg2);
50833 wxPyEndAllowThreads(__tstate);
50834 if (PyErr_Occurred()) SWIG_fail;
50835 }
50836 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50844 PyObject *resultobj = 0;
50845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50846 size_t arg2 ;
50847 wxGBSpan result;
50848 void *argp1 = 0 ;
50849 int res1 = 0 ;
50850 size_t val2 ;
50851 int ecode2 = 0 ;
50852
50853 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50855 if (!SWIG_IsOK(res1)) {
50856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50857 }
50858 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50859 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50860 if (!SWIG_IsOK(ecode2)) {
50861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50862 }
50863 arg2 = static_cast< size_t >(val2);
50864 {
50865 PyThreadState* __tstate = wxPyBeginAllowThreads();
50866 result = (arg1)->GetItemSpan(arg2);
50867 wxPyEndAllowThreads(__tstate);
50868 if (PyErr_Occurred()) SWIG_fail;
50869 }
50870 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50871 return resultobj;
50872 fail:
50873 return NULL;
50874 }
50875
50876
50877 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50878 int argc;
50879 PyObject *argv[3];
50880
50881 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50882 --argc;
50883 if (argc == 2) {
50884 int _v = 0;
50885 {
50886 void *vptr = 0;
50887 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50888 _v = SWIG_CheckState(res);
50889 }
50890 if (!_v) goto check_1;
50891 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50892 }
50893 check_1:
50894
50895 if (argc == 2) {
50896 int _v = 0;
50897 {
50898 void *vptr = 0;
50899 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50900 _v = SWIG_CheckState(res);
50901 }
50902 if (!_v) goto check_2;
50903 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50904 }
50905 check_2:
50906
50907 if (argc == 2) {
50908 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50909 }
50910
50911 fail:
50912 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50913 return NULL;
50914 }
50915
50916
50917 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50918 PyObject *resultobj = 0;
50919 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50920 wxWindow *arg2 = (wxWindow *) 0 ;
50921 wxGBSpan *arg3 = 0 ;
50922 bool result;
50923 void *argp1 = 0 ;
50924 int res1 = 0 ;
50925 void *argp2 = 0 ;
50926 int res2 = 0 ;
50927 wxGBSpan temp3 ;
50928
50929 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50931 if (!SWIG_IsOK(res1)) {
50932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50933 }
50934 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50935 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50936 if (!SWIG_IsOK(res2)) {
50937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50938 }
50939 arg2 = reinterpret_cast< wxWindow * >(argp2);
50940 {
50941 arg3 = &temp3;
50942 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50943 }
50944 {
50945 PyThreadState* __tstate = wxPyBeginAllowThreads();
50946 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50947 wxPyEndAllowThreads(__tstate);
50948 if (PyErr_Occurred()) SWIG_fail;
50949 }
50950 {
50951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50952 }
50953 return resultobj;
50954 fail:
50955 return NULL;
50956 }
50957
50958
50959 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50960 PyObject *resultobj = 0;
50961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50962 wxSizer *arg2 = (wxSizer *) 0 ;
50963 wxGBSpan *arg3 = 0 ;
50964 bool result;
50965 void *argp1 = 0 ;
50966 int res1 = 0 ;
50967 void *argp2 = 0 ;
50968 int res2 = 0 ;
50969 wxGBSpan temp3 ;
50970
50971 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50973 if (!SWIG_IsOK(res1)) {
50974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50975 }
50976 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50977 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50978 if (!SWIG_IsOK(res2)) {
50979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50980 }
50981 arg2 = reinterpret_cast< wxSizer * >(argp2);
50982 {
50983 arg3 = &temp3;
50984 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50985 }
50986 {
50987 PyThreadState* __tstate = wxPyBeginAllowThreads();
50988 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50989 wxPyEndAllowThreads(__tstate);
50990 if (PyErr_Occurred()) SWIG_fail;
50991 }
50992 {
50993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50994 }
50995 return resultobj;
50996 fail:
50997 return NULL;
50998 }
50999
51000
51001 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51002 PyObject *resultobj = 0;
51003 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51004 size_t arg2 ;
51005 wxGBSpan *arg3 = 0 ;
51006 bool result;
51007 void *argp1 = 0 ;
51008 int res1 = 0 ;
51009 size_t val2 ;
51010 int ecode2 = 0 ;
51011 wxGBSpan temp3 ;
51012
51013 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51015 if (!SWIG_IsOK(res1)) {
51016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51017 }
51018 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51019 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51020 if (!SWIG_IsOK(ecode2)) {
51021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51022 }
51023 arg2 = static_cast< size_t >(val2);
51024 {
51025 arg3 = &temp3;
51026 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51027 }
51028 {
51029 PyThreadState* __tstate = wxPyBeginAllowThreads();
51030 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51031 wxPyEndAllowThreads(__tstate);
51032 if (PyErr_Occurred()) SWIG_fail;
51033 }
51034 {
51035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51036 }
51037 return resultobj;
51038 fail:
51039 return NULL;
51040 }
51041
51042
51043 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51044 int argc;
51045 PyObject *argv[4];
51046
51047 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51048 --argc;
51049 if (argc == 3) {
51050 int _v = 0;
51051 {
51052 void *vptr = 0;
51053 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51054 _v = SWIG_CheckState(res);
51055 }
51056 if (!_v) goto check_1;
51057 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51058 }
51059 check_1:
51060
51061 if (argc == 3) {
51062 int _v = 0;
51063 {
51064 void *vptr = 0;
51065 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51066 _v = SWIG_CheckState(res);
51067 }
51068 if (!_v) goto check_2;
51069 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51070 }
51071 check_2:
51072
51073 if (argc == 3) {
51074 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51075 }
51076
51077 fail:
51078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51079 return NULL;
51080 }
51081
51082
51083 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51084 PyObject *resultobj = 0;
51085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51086 wxWindow *arg2 = (wxWindow *) 0 ;
51087 wxGBSizerItem *result = 0 ;
51088 void *argp1 = 0 ;
51089 int res1 = 0 ;
51090 void *argp2 = 0 ;
51091 int res2 = 0 ;
51092
51093 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51095 if (!SWIG_IsOK(res1)) {
51096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51097 }
51098 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51099 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51100 if (!SWIG_IsOK(res2)) {
51101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51102 }
51103 arg2 = reinterpret_cast< wxWindow * >(argp2);
51104 {
51105 PyThreadState* __tstate = wxPyBeginAllowThreads();
51106 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51107 wxPyEndAllowThreads(__tstate);
51108 if (PyErr_Occurred()) SWIG_fail;
51109 }
51110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51111 return resultobj;
51112 fail:
51113 return NULL;
51114 }
51115
51116
51117 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51118 PyObject *resultobj = 0;
51119 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51120 wxSizer *arg2 = (wxSizer *) 0 ;
51121 wxGBSizerItem *result = 0 ;
51122 void *argp1 = 0 ;
51123 int res1 = 0 ;
51124 void *argp2 = 0 ;
51125 int res2 = 0 ;
51126
51127 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51129 if (!SWIG_IsOK(res1)) {
51130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51131 }
51132 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51133 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51134 if (!SWIG_IsOK(res2)) {
51135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51136 }
51137 arg2 = reinterpret_cast< wxSizer * >(argp2);
51138 {
51139 PyThreadState* __tstate = wxPyBeginAllowThreads();
51140 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51141 wxPyEndAllowThreads(__tstate);
51142 if (PyErr_Occurred()) SWIG_fail;
51143 }
51144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51145 return resultobj;
51146 fail:
51147 return NULL;
51148 }
51149
51150
51151 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51152 int argc;
51153 PyObject *argv[3];
51154
51155 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51156 --argc;
51157 if (argc == 2) {
51158 int _v = 0;
51159 {
51160 void *vptr = 0;
51161 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51162 _v = SWIG_CheckState(res);
51163 }
51164 if (!_v) goto check_1;
51165 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51166 }
51167 check_1:
51168
51169 if (argc == 2) {
51170 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51171 }
51172
51173 fail:
51174 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51175 return NULL;
51176 }
51177
51178
51179 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51180 PyObject *resultobj = 0;
51181 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51182 wxGBPosition *arg2 = 0 ;
51183 wxGBSizerItem *result = 0 ;
51184 void *argp1 = 0 ;
51185 int res1 = 0 ;
51186 wxGBPosition temp2 ;
51187 PyObject * obj0 = 0 ;
51188 PyObject * obj1 = 0 ;
51189 char * kwnames[] = {
51190 (char *) "self",(char *) "pos", NULL
51191 };
51192
51193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51197 }
51198 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51199 {
51200 arg2 = &temp2;
51201 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51202 }
51203 {
51204 PyThreadState* __tstate = wxPyBeginAllowThreads();
51205 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51206 wxPyEndAllowThreads(__tstate);
51207 if (PyErr_Occurred()) SWIG_fail;
51208 }
51209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51210 return resultobj;
51211 fail:
51212 return NULL;
51213 }
51214
51215
51216 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51217 PyObject *resultobj = 0;
51218 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51219 wxPoint *arg2 = 0 ;
51220 wxGBSizerItem *result = 0 ;
51221 void *argp1 = 0 ;
51222 int res1 = 0 ;
51223 wxPoint temp2 ;
51224 PyObject * obj0 = 0 ;
51225 PyObject * obj1 = 0 ;
51226 char * kwnames[] = {
51227 (char *) "self",(char *) "pt", NULL
51228 };
51229
51230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51232 if (!SWIG_IsOK(res1)) {
51233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51234 }
51235 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51236 {
51237 arg2 = &temp2;
51238 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51239 }
51240 {
51241 PyThreadState* __tstate = wxPyBeginAllowThreads();
51242 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51243 wxPyEndAllowThreads(__tstate);
51244 if (PyErr_Occurred()) SWIG_fail;
51245 }
51246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51247 return resultobj;
51248 fail:
51249 return NULL;
51250 }
51251
51252
51253 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51254 PyObject *resultobj = 0;
51255 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51256 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51257 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51258 bool result;
51259 void *argp1 = 0 ;
51260 int res1 = 0 ;
51261 void *argp2 = 0 ;
51262 int res2 = 0 ;
51263 void *argp3 = 0 ;
51264 int res3 = 0 ;
51265 PyObject * obj0 = 0 ;
51266 PyObject * obj1 = 0 ;
51267 PyObject * obj2 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51279 if (!SWIG_IsOK(res2)) {
51280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51281 }
51282 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51283 if (obj2) {
51284 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51285 if (!SWIG_IsOK(res3)) {
51286 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51287 }
51288 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51289 }
51290 {
51291 PyThreadState* __tstate = wxPyBeginAllowThreads();
51292 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51293 wxPyEndAllowThreads(__tstate);
51294 if (PyErr_Occurred()) SWIG_fail;
51295 }
51296 {
51297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51298 }
51299 return resultobj;
51300 fail:
51301 return NULL;
51302 }
51303
51304
51305 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51306 PyObject *resultobj = 0;
51307 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51308 wxGBPosition *arg2 = 0 ;
51309 wxGBSpan *arg3 = 0 ;
51310 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51311 bool result;
51312 void *argp1 = 0 ;
51313 int res1 = 0 ;
51314 wxGBPosition temp2 ;
51315 wxGBSpan temp3 ;
51316 void *argp4 = 0 ;
51317 int res4 = 0 ;
51318 PyObject * obj0 = 0 ;
51319 PyObject * obj1 = 0 ;
51320 PyObject * obj2 = 0 ;
51321 PyObject * obj3 = 0 ;
51322 char * kwnames[] = {
51323 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51324 };
51325
51326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51328 if (!SWIG_IsOK(res1)) {
51329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51330 }
51331 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51332 {
51333 arg2 = &temp2;
51334 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51335 }
51336 {
51337 arg3 = &temp3;
51338 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51339 }
51340 if (obj3) {
51341 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51342 if (!SWIG_IsOK(res4)) {
51343 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51344 }
51345 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51346 }
51347 {
51348 PyThreadState* __tstate = wxPyBeginAllowThreads();
51349 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51350 wxPyEndAllowThreads(__tstate);
51351 if (PyErr_Occurred()) SWIG_fail;
51352 }
51353 {
51354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51355 }
51356 return resultobj;
51357 fail:
51358 return NULL;
51359 }
51360
51361
51362 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51363 PyObject *obj;
51364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51366 return SWIG_Py_Void();
51367 }
51368
51369 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51370 return SWIG_Python_InitShadowInstance(args);
51371 }
51372
51373 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51374 PyObject *resultobj = 0;
51375 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51376 wxRelationship arg2 ;
51377 wxWindow *arg3 = (wxWindow *) 0 ;
51378 wxEdge arg4 ;
51379 int arg5 = (int) 0 ;
51380 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51381 void *argp1 = 0 ;
51382 int res1 = 0 ;
51383 int val2 ;
51384 int ecode2 = 0 ;
51385 void *argp3 = 0 ;
51386 int res3 = 0 ;
51387 int val4 ;
51388 int ecode4 = 0 ;
51389 int val5 ;
51390 int ecode5 = 0 ;
51391 int val6 ;
51392 int ecode6 = 0 ;
51393 PyObject * obj0 = 0 ;
51394 PyObject * obj1 = 0 ;
51395 PyObject * obj2 = 0 ;
51396 PyObject * obj3 = 0 ;
51397 PyObject * obj4 = 0 ;
51398 PyObject * obj5 = 0 ;
51399 char * kwnames[] = {
51400 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51401 };
51402
51403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51405 if (!SWIG_IsOK(res1)) {
51406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51407 }
51408 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51409 ecode2 = SWIG_AsVal_int(obj1, &val2);
51410 if (!SWIG_IsOK(ecode2)) {
51411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51412 }
51413 arg2 = static_cast< wxRelationship >(val2);
51414 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51415 if (!SWIG_IsOK(res3)) {
51416 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51417 }
51418 arg3 = reinterpret_cast< wxWindow * >(argp3);
51419 ecode4 = SWIG_AsVal_int(obj3, &val4);
51420 if (!SWIG_IsOK(ecode4)) {
51421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51422 }
51423 arg4 = static_cast< wxEdge >(val4);
51424 if (obj4) {
51425 ecode5 = SWIG_AsVal_int(obj4, &val5);
51426 if (!SWIG_IsOK(ecode5)) {
51427 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51428 }
51429 arg5 = static_cast< int >(val5);
51430 }
51431 if (obj5) {
51432 ecode6 = SWIG_AsVal_int(obj5, &val6);
51433 if (!SWIG_IsOK(ecode6)) {
51434 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51435 }
51436 arg6 = static_cast< int >(val6);
51437 }
51438 {
51439 PyThreadState* __tstate = wxPyBeginAllowThreads();
51440 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51441 wxPyEndAllowThreads(__tstate);
51442 if (PyErr_Occurred()) SWIG_fail;
51443 }
51444 resultobj = SWIG_Py_Void();
51445 return resultobj;
51446 fail:
51447 return NULL;
51448 }
51449
51450
51451 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51452 PyObject *resultobj = 0;
51453 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51454 wxWindow *arg2 = (wxWindow *) 0 ;
51455 int arg3 = (int) 0 ;
51456 void *argp1 = 0 ;
51457 int res1 = 0 ;
51458 void *argp2 = 0 ;
51459 int res2 = 0 ;
51460 int val3 ;
51461 int ecode3 = 0 ;
51462 PyObject * obj0 = 0 ;
51463 PyObject * obj1 = 0 ;
51464 PyObject * obj2 = 0 ;
51465 char * kwnames[] = {
51466 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51467 };
51468
51469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51471 if (!SWIG_IsOK(res1)) {
51472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51473 }
51474 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51476 if (!SWIG_IsOK(res2)) {
51477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51478 }
51479 arg2 = reinterpret_cast< wxWindow * >(argp2);
51480 if (obj2) {
51481 ecode3 = SWIG_AsVal_int(obj2, &val3);
51482 if (!SWIG_IsOK(ecode3)) {
51483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51484 }
51485 arg3 = static_cast< int >(val3);
51486 }
51487 {
51488 PyThreadState* __tstate = wxPyBeginAllowThreads();
51489 (arg1)->LeftOf(arg2,arg3);
51490 wxPyEndAllowThreads(__tstate);
51491 if (PyErr_Occurred()) SWIG_fail;
51492 }
51493 resultobj = SWIG_Py_Void();
51494 return resultobj;
51495 fail:
51496 return NULL;
51497 }
51498
51499
51500 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51501 PyObject *resultobj = 0;
51502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51503 wxWindow *arg2 = (wxWindow *) 0 ;
51504 int arg3 = (int) 0 ;
51505 void *argp1 = 0 ;
51506 int res1 = 0 ;
51507 void *argp2 = 0 ;
51508 int res2 = 0 ;
51509 int val3 ;
51510 int ecode3 = 0 ;
51511 PyObject * obj0 = 0 ;
51512 PyObject * obj1 = 0 ;
51513 PyObject * obj2 = 0 ;
51514 char * kwnames[] = {
51515 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51516 };
51517
51518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51520 if (!SWIG_IsOK(res1)) {
51521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51522 }
51523 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51525 if (!SWIG_IsOK(res2)) {
51526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51527 }
51528 arg2 = reinterpret_cast< wxWindow * >(argp2);
51529 if (obj2) {
51530 ecode3 = SWIG_AsVal_int(obj2, &val3);
51531 if (!SWIG_IsOK(ecode3)) {
51532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51533 }
51534 arg3 = static_cast< int >(val3);
51535 }
51536 {
51537 PyThreadState* __tstate = wxPyBeginAllowThreads();
51538 (arg1)->RightOf(arg2,arg3);
51539 wxPyEndAllowThreads(__tstate);
51540 if (PyErr_Occurred()) SWIG_fail;
51541 }
51542 resultobj = SWIG_Py_Void();
51543 return resultobj;
51544 fail:
51545 return NULL;
51546 }
51547
51548
51549 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51550 PyObject *resultobj = 0;
51551 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51552 wxWindow *arg2 = (wxWindow *) 0 ;
51553 int arg3 = (int) 0 ;
51554 void *argp1 = 0 ;
51555 int res1 = 0 ;
51556 void *argp2 = 0 ;
51557 int res2 = 0 ;
51558 int val3 ;
51559 int ecode3 = 0 ;
51560 PyObject * obj0 = 0 ;
51561 PyObject * obj1 = 0 ;
51562 PyObject * obj2 = 0 ;
51563 char * kwnames[] = {
51564 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51565 };
51566
51567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51569 if (!SWIG_IsOK(res1)) {
51570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51571 }
51572 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51574 if (!SWIG_IsOK(res2)) {
51575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51576 }
51577 arg2 = reinterpret_cast< wxWindow * >(argp2);
51578 if (obj2) {
51579 ecode3 = SWIG_AsVal_int(obj2, &val3);
51580 if (!SWIG_IsOK(ecode3)) {
51581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51582 }
51583 arg3 = static_cast< int >(val3);
51584 }
51585 {
51586 PyThreadState* __tstate = wxPyBeginAllowThreads();
51587 (arg1)->Above(arg2,arg3);
51588 wxPyEndAllowThreads(__tstate);
51589 if (PyErr_Occurred()) SWIG_fail;
51590 }
51591 resultobj = SWIG_Py_Void();
51592 return resultobj;
51593 fail:
51594 return NULL;
51595 }
51596
51597
51598 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51599 PyObject *resultobj = 0;
51600 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51601 wxWindow *arg2 = (wxWindow *) 0 ;
51602 int arg3 = (int) 0 ;
51603 void *argp1 = 0 ;
51604 int res1 = 0 ;
51605 void *argp2 = 0 ;
51606 int res2 = 0 ;
51607 int val3 ;
51608 int ecode3 = 0 ;
51609 PyObject * obj0 = 0 ;
51610 PyObject * obj1 = 0 ;
51611 PyObject * obj2 = 0 ;
51612 char * kwnames[] = {
51613 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51614 };
51615
51616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51618 if (!SWIG_IsOK(res1)) {
51619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51620 }
51621 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51623 if (!SWIG_IsOK(res2)) {
51624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51625 }
51626 arg2 = reinterpret_cast< wxWindow * >(argp2);
51627 if (obj2) {
51628 ecode3 = SWIG_AsVal_int(obj2, &val3);
51629 if (!SWIG_IsOK(ecode3)) {
51630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51631 }
51632 arg3 = static_cast< int >(val3);
51633 }
51634 {
51635 PyThreadState* __tstate = wxPyBeginAllowThreads();
51636 (arg1)->Below(arg2,arg3);
51637 wxPyEndAllowThreads(__tstate);
51638 if (PyErr_Occurred()) SWIG_fail;
51639 }
51640 resultobj = SWIG_Py_Void();
51641 return resultobj;
51642 fail:
51643 return NULL;
51644 }
51645
51646
51647 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51648 PyObject *resultobj = 0;
51649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51650 wxWindow *arg2 = (wxWindow *) 0 ;
51651 wxEdge arg3 ;
51652 int arg4 = (int) 0 ;
51653 void *argp1 = 0 ;
51654 int res1 = 0 ;
51655 void *argp2 = 0 ;
51656 int res2 = 0 ;
51657 int val3 ;
51658 int ecode3 = 0 ;
51659 int val4 ;
51660 int ecode4 = 0 ;
51661 PyObject * obj0 = 0 ;
51662 PyObject * obj1 = 0 ;
51663 PyObject * obj2 = 0 ;
51664 PyObject * obj3 = 0 ;
51665 char * kwnames[] = {
51666 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51667 };
51668
51669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51673 }
51674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51676 if (!SWIG_IsOK(res2)) {
51677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51678 }
51679 arg2 = reinterpret_cast< wxWindow * >(argp2);
51680 ecode3 = SWIG_AsVal_int(obj2, &val3);
51681 if (!SWIG_IsOK(ecode3)) {
51682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51683 }
51684 arg3 = static_cast< wxEdge >(val3);
51685 if (obj3) {
51686 ecode4 = SWIG_AsVal_int(obj3, &val4);
51687 if (!SWIG_IsOK(ecode4)) {
51688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51689 }
51690 arg4 = static_cast< int >(val4);
51691 }
51692 {
51693 PyThreadState* __tstate = wxPyBeginAllowThreads();
51694 (arg1)->SameAs(arg2,arg3,arg4);
51695 wxPyEndAllowThreads(__tstate);
51696 if (PyErr_Occurred()) SWIG_fail;
51697 }
51698 resultobj = SWIG_Py_Void();
51699 return resultobj;
51700 fail:
51701 return NULL;
51702 }
51703
51704
51705 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51706 PyObject *resultobj = 0;
51707 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51708 wxWindow *arg2 = (wxWindow *) 0 ;
51709 wxEdge arg3 ;
51710 int arg4 ;
51711 void *argp1 = 0 ;
51712 int res1 = 0 ;
51713 void *argp2 = 0 ;
51714 int res2 = 0 ;
51715 int val3 ;
51716 int ecode3 = 0 ;
51717 int val4 ;
51718 int ecode4 = 0 ;
51719 PyObject * obj0 = 0 ;
51720 PyObject * obj1 = 0 ;
51721 PyObject * obj2 = 0 ;
51722 PyObject * obj3 = 0 ;
51723 char * kwnames[] = {
51724 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51725 };
51726
51727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51729 if (!SWIG_IsOK(res1)) {
51730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51731 }
51732 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51734 if (!SWIG_IsOK(res2)) {
51735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51736 }
51737 arg2 = reinterpret_cast< wxWindow * >(argp2);
51738 ecode3 = SWIG_AsVal_int(obj2, &val3);
51739 if (!SWIG_IsOK(ecode3)) {
51740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51741 }
51742 arg3 = static_cast< wxEdge >(val3);
51743 ecode4 = SWIG_AsVal_int(obj3, &val4);
51744 if (!SWIG_IsOK(ecode4)) {
51745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51746 }
51747 arg4 = static_cast< int >(val4);
51748 {
51749 PyThreadState* __tstate = wxPyBeginAllowThreads();
51750 (arg1)->PercentOf(arg2,arg3,arg4);
51751 wxPyEndAllowThreads(__tstate);
51752 if (PyErr_Occurred()) SWIG_fail;
51753 }
51754 resultobj = SWIG_Py_Void();
51755 return resultobj;
51756 fail:
51757 return NULL;
51758 }
51759
51760
51761 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51762 PyObject *resultobj = 0;
51763 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51764 int arg2 ;
51765 void *argp1 = 0 ;
51766 int res1 = 0 ;
51767 int val2 ;
51768 int ecode2 = 0 ;
51769 PyObject * obj0 = 0 ;
51770 PyObject * obj1 = 0 ;
51771 char * kwnames[] = {
51772 (char *) "self",(char *) "val", NULL
51773 };
51774
51775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51777 if (!SWIG_IsOK(res1)) {
51778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51779 }
51780 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51781 ecode2 = SWIG_AsVal_int(obj1, &val2);
51782 if (!SWIG_IsOK(ecode2)) {
51783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51784 }
51785 arg2 = static_cast< int >(val2);
51786 {
51787 PyThreadState* __tstate = wxPyBeginAllowThreads();
51788 (arg1)->Absolute(arg2);
51789 wxPyEndAllowThreads(__tstate);
51790 if (PyErr_Occurred()) SWIG_fail;
51791 }
51792 resultobj = SWIG_Py_Void();
51793 return resultobj;
51794 fail:
51795 return NULL;
51796 }
51797
51798
51799 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51800 PyObject *resultobj = 0;
51801 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51802 void *argp1 = 0 ;
51803 int res1 = 0 ;
51804 PyObject *swig_obj[1] ;
51805
51806 if (!args) SWIG_fail;
51807 swig_obj[0] = args;
51808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51809 if (!SWIG_IsOK(res1)) {
51810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51811 }
51812 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51813 {
51814 PyThreadState* __tstate = wxPyBeginAllowThreads();
51815 (arg1)->Unconstrained();
51816 wxPyEndAllowThreads(__tstate);
51817 if (PyErr_Occurred()) SWIG_fail;
51818 }
51819 resultobj = SWIG_Py_Void();
51820 return resultobj;
51821 fail:
51822 return NULL;
51823 }
51824
51825
51826 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51827 PyObject *resultobj = 0;
51828 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51829 void *argp1 = 0 ;
51830 int res1 = 0 ;
51831 PyObject *swig_obj[1] ;
51832
51833 if (!args) SWIG_fail;
51834 swig_obj[0] = args;
51835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51836 if (!SWIG_IsOK(res1)) {
51837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51838 }
51839 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51840 {
51841 PyThreadState* __tstate = wxPyBeginAllowThreads();
51842 (arg1)->AsIs();
51843 wxPyEndAllowThreads(__tstate);
51844 if (PyErr_Occurred()) SWIG_fail;
51845 }
51846 resultobj = SWIG_Py_Void();
51847 return resultobj;
51848 fail:
51849 return NULL;
51850 }
51851
51852
51853 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51854 PyObject *resultobj = 0;
51855 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51856 wxWindow *result = 0 ;
51857 void *argp1 = 0 ;
51858 int res1 = 0 ;
51859 PyObject *swig_obj[1] ;
51860
51861 if (!args) SWIG_fail;
51862 swig_obj[0] = args;
51863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51864 if (!SWIG_IsOK(res1)) {
51865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51866 }
51867 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51868 {
51869 PyThreadState* __tstate = wxPyBeginAllowThreads();
51870 result = (wxWindow *)(arg1)->GetOtherWindow();
51871 wxPyEndAllowThreads(__tstate);
51872 if (PyErr_Occurred()) SWIG_fail;
51873 }
51874 {
51875 resultobj = wxPyMake_wxObject(result, 0);
51876 }
51877 return resultobj;
51878 fail:
51879 return NULL;
51880 }
51881
51882
51883 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51884 PyObject *resultobj = 0;
51885 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51886 wxEdge result;
51887 void *argp1 = 0 ;
51888 int res1 = 0 ;
51889 PyObject *swig_obj[1] ;
51890
51891 if (!args) SWIG_fail;
51892 swig_obj[0] = args;
51893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51894 if (!SWIG_IsOK(res1)) {
51895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51896 }
51897 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51898 {
51899 PyThreadState* __tstate = wxPyBeginAllowThreads();
51900 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51901 wxPyEndAllowThreads(__tstate);
51902 if (PyErr_Occurred()) SWIG_fail;
51903 }
51904 resultobj = SWIG_From_int(static_cast< int >(result));
51905 return resultobj;
51906 fail:
51907 return NULL;
51908 }
51909
51910
51911 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51912 PyObject *resultobj = 0;
51913 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51914 wxEdge arg2 ;
51915 void *argp1 = 0 ;
51916 int res1 = 0 ;
51917 int val2 ;
51918 int ecode2 = 0 ;
51919 PyObject * obj0 = 0 ;
51920 PyObject * obj1 = 0 ;
51921 char * kwnames[] = {
51922 (char *) "self",(char *) "which", NULL
51923 };
51924
51925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51927 if (!SWIG_IsOK(res1)) {
51928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51929 }
51930 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51931 ecode2 = SWIG_AsVal_int(obj1, &val2);
51932 if (!SWIG_IsOK(ecode2)) {
51933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51934 }
51935 arg2 = static_cast< wxEdge >(val2);
51936 {
51937 PyThreadState* __tstate = wxPyBeginAllowThreads();
51938 (arg1)->SetEdge(arg2);
51939 wxPyEndAllowThreads(__tstate);
51940 if (PyErr_Occurred()) SWIG_fail;
51941 }
51942 resultobj = SWIG_Py_Void();
51943 return resultobj;
51944 fail:
51945 return NULL;
51946 }
51947
51948
51949 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51950 PyObject *resultobj = 0;
51951 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51952 int arg2 ;
51953 void *argp1 = 0 ;
51954 int res1 = 0 ;
51955 int val2 ;
51956 int ecode2 = 0 ;
51957 PyObject * obj0 = 0 ;
51958 PyObject * obj1 = 0 ;
51959 char * kwnames[] = {
51960 (char *) "self",(char *) "v", NULL
51961 };
51962
51963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51965 if (!SWIG_IsOK(res1)) {
51966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51967 }
51968 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51969 ecode2 = SWIG_AsVal_int(obj1, &val2);
51970 if (!SWIG_IsOK(ecode2)) {
51971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51972 }
51973 arg2 = static_cast< int >(val2);
51974 {
51975 PyThreadState* __tstate = wxPyBeginAllowThreads();
51976 (arg1)->SetValue(arg2);
51977 wxPyEndAllowThreads(__tstate);
51978 if (PyErr_Occurred()) SWIG_fail;
51979 }
51980 resultobj = SWIG_Py_Void();
51981 return resultobj;
51982 fail:
51983 return NULL;
51984 }
51985
51986
51987 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51988 PyObject *resultobj = 0;
51989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51990 int result;
51991 void *argp1 = 0 ;
51992 int res1 = 0 ;
51993 PyObject *swig_obj[1] ;
51994
51995 if (!args) SWIG_fail;
51996 swig_obj[0] = args;
51997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51998 if (!SWIG_IsOK(res1)) {
51999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52000 }
52001 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52002 {
52003 PyThreadState* __tstate = wxPyBeginAllowThreads();
52004 result = (int)(arg1)->GetMargin();
52005 wxPyEndAllowThreads(__tstate);
52006 if (PyErr_Occurred()) SWIG_fail;
52007 }
52008 resultobj = SWIG_From_int(static_cast< int >(result));
52009 return resultobj;
52010 fail:
52011 return NULL;
52012 }
52013
52014
52015 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52016 PyObject *resultobj = 0;
52017 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52018 int arg2 ;
52019 void *argp1 = 0 ;
52020 int res1 = 0 ;
52021 int val2 ;
52022 int ecode2 = 0 ;
52023 PyObject * obj0 = 0 ;
52024 PyObject * obj1 = 0 ;
52025 char * kwnames[] = {
52026 (char *) "self",(char *) "m", NULL
52027 };
52028
52029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52031 if (!SWIG_IsOK(res1)) {
52032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52033 }
52034 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52035 ecode2 = SWIG_AsVal_int(obj1, &val2);
52036 if (!SWIG_IsOK(ecode2)) {
52037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52038 }
52039 arg2 = static_cast< int >(val2);
52040 {
52041 PyThreadState* __tstate = wxPyBeginAllowThreads();
52042 (arg1)->SetMargin(arg2);
52043 wxPyEndAllowThreads(__tstate);
52044 if (PyErr_Occurred()) SWIG_fail;
52045 }
52046 resultobj = SWIG_Py_Void();
52047 return resultobj;
52048 fail:
52049 return NULL;
52050 }
52051
52052
52053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52054 PyObject *resultobj = 0;
52055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52056 int result;
52057 void *argp1 = 0 ;
52058 int res1 = 0 ;
52059 PyObject *swig_obj[1] ;
52060
52061 if (!args) SWIG_fail;
52062 swig_obj[0] = args;
52063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52064 if (!SWIG_IsOK(res1)) {
52065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52066 }
52067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52068 {
52069 PyThreadState* __tstate = wxPyBeginAllowThreads();
52070 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52071 wxPyEndAllowThreads(__tstate);
52072 if (PyErr_Occurred()) SWIG_fail;
52073 }
52074 resultobj = SWIG_From_int(static_cast< int >(result));
52075 return resultobj;
52076 fail:
52077 return NULL;
52078 }
52079
52080
52081 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52082 PyObject *resultobj = 0;
52083 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52084 int result;
52085 void *argp1 = 0 ;
52086 int res1 = 0 ;
52087 PyObject *swig_obj[1] ;
52088
52089 if (!args) SWIG_fail;
52090 swig_obj[0] = args;
52091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52092 if (!SWIG_IsOK(res1)) {
52093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52094 }
52095 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52096 {
52097 PyThreadState* __tstate = wxPyBeginAllowThreads();
52098 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52099 wxPyEndAllowThreads(__tstate);
52100 if (PyErr_Occurred()) SWIG_fail;
52101 }
52102 resultobj = SWIG_From_int(static_cast< int >(result));
52103 return resultobj;
52104 fail:
52105 return NULL;
52106 }
52107
52108
52109 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52110 PyObject *resultobj = 0;
52111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52112 int result;
52113 void *argp1 = 0 ;
52114 int res1 = 0 ;
52115 PyObject *swig_obj[1] ;
52116
52117 if (!args) SWIG_fail;
52118 swig_obj[0] = args;
52119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52120 if (!SWIG_IsOK(res1)) {
52121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52122 }
52123 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52124 {
52125 PyThreadState* __tstate = wxPyBeginAllowThreads();
52126 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52127 wxPyEndAllowThreads(__tstate);
52128 if (PyErr_Occurred()) SWIG_fail;
52129 }
52130 resultobj = SWIG_From_int(static_cast< int >(result));
52131 return resultobj;
52132 fail:
52133 return NULL;
52134 }
52135
52136
52137 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52138 PyObject *resultobj = 0;
52139 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52140 bool result;
52141 void *argp1 = 0 ;
52142 int res1 = 0 ;
52143 PyObject *swig_obj[1] ;
52144
52145 if (!args) SWIG_fail;
52146 swig_obj[0] = args;
52147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52148 if (!SWIG_IsOK(res1)) {
52149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52150 }
52151 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52152 {
52153 PyThreadState* __tstate = wxPyBeginAllowThreads();
52154 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52155 wxPyEndAllowThreads(__tstate);
52156 if (PyErr_Occurred()) SWIG_fail;
52157 }
52158 {
52159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52160 }
52161 return resultobj;
52162 fail:
52163 return NULL;
52164 }
52165
52166
52167 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52168 PyObject *resultobj = 0;
52169 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52170 bool arg2 ;
52171 void *argp1 = 0 ;
52172 int res1 = 0 ;
52173 bool val2 ;
52174 int ecode2 = 0 ;
52175 PyObject * obj0 = 0 ;
52176 PyObject * obj1 = 0 ;
52177 char * kwnames[] = {
52178 (char *) "self",(char *) "d", NULL
52179 };
52180
52181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52183 if (!SWIG_IsOK(res1)) {
52184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52185 }
52186 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52187 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52188 if (!SWIG_IsOK(ecode2)) {
52189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52190 }
52191 arg2 = static_cast< bool >(val2);
52192 {
52193 PyThreadState* __tstate = wxPyBeginAllowThreads();
52194 (arg1)->SetDone(arg2);
52195 wxPyEndAllowThreads(__tstate);
52196 if (PyErr_Occurred()) SWIG_fail;
52197 }
52198 resultobj = SWIG_Py_Void();
52199 return resultobj;
52200 fail:
52201 return NULL;
52202 }
52203
52204
52205 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52206 PyObject *resultobj = 0;
52207 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52208 wxRelationship result;
52209 void *argp1 = 0 ;
52210 int res1 = 0 ;
52211 PyObject *swig_obj[1] ;
52212
52213 if (!args) SWIG_fail;
52214 swig_obj[0] = args;
52215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52216 if (!SWIG_IsOK(res1)) {
52217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52218 }
52219 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52220 {
52221 PyThreadState* __tstate = wxPyBeginAllowThreads();
52222 result = (wxRelationship)(arg1)->GetRelationship();
52223 wxPyEndAllowThreads(__tstate);
52224 if (PyErr_Occurred()) SWIG_fail;
52225 }
52226 resultobj = SWIG_From_int(static_cast< int >(result));
52227 return resultobj;
52228 fail:
52229 return NULL;
52230 }
52231
52232
52233 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52234 PyObject *resultobj = 0;
52235 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52236 wxRelationship arg2 ;
52237 void *argp1 = 0 ;
52238 int res1 = 0 ;
52239 int val2 ;
52240 int ecode2 = 0 ;
52241 PyObject * obj0 = 0 ;
52242 PyObject * obj1 = 0 ;
52243 char * kwnames[] = {
52244 (char *) "self",(char *) "r", NULL
52245 };
52246
52247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52249 if (!SWIG_IsOK(res1)) {
52250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52251 }
52252 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52253 ecode2 = SWIG_AsVal_int(obj1, &val2);
52254 if (!SWIG_IsOK(ecode2)) {
52255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52256 }
52257 arg2 = static_cast< wxRelationship >(val2);
52258 {
52259 PyThreadState* __tstate = wxPyBeginAllowThreads();
52260 (arg1)->SetRelationship(arg2);
52261 wxPyEndAllowThreads(__tstate);
52262 if (PyErr_Occurred()) SWIG_fail;
52263 }
52264 resultobj = SWIG_Py_Void();
52265 return resultobj;
52266 fail:
52267 return NULL;
52268 }
52269
52270
52271 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52272 PyObject *resultobj = 0;
52273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52274 wxWindow *arg2 = (wxWindow *) 0 ;
52275 bool result;
52276 void *argp1 = 0 ;
52277 int res1 = 0 ;
52278 void *argp2 = 0 ;
52279 int res2 = 0 ;
52280 PyObject * obj0 = 0 ;
52281 PyObject * obj1 = 0 ;
52282 char * kwnames[] = {
52283 (char *) "self",(char *) "otherW", NULL
52284 };
52285
52286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52288 if (!SWIG_IsOK(res1)) {
52289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52290 }
52291 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52293 if (!SWIG_IsOK(res2)) {
52294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52295 }
52296 arg2 = reinterpret_cast< wxWindow * >(argp2);
52297 {
52298 PyThreadState* __tstate = wxPyBeginAllowThreads();
52299 result = (bool)(arg1)->ResetIfWin(arg2);
52300 wxPyEndAllowThreads(__tstate);
52301 if (PyErr_Occurred()) SWIG_fail;
52302 }
52303 {
52304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52305 }
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52313 PyObject *resultobj = 0;
52314 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52315 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52316 wxWindow *arg3 = (wxWindow *) 0 ;
52317 bool result;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 void *argp2 = 0 ;
52321 int res2 = 0 ;
52322 void *argp3 = 0 ;
52323 int res3 = 0 ;
52324 PyObject * obj0 = 0 ;
52325 PyObject * obj1 = 0 ;
52326 PyObject * obj2 = 0 ;
52327 char * kwnames[] = {
52328 (char *) "self",(char *) "constraints",(char *) "win", NULL
52329 };
52330
52331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52333 if (!SWIG_IsOK(res1)) {
52334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52335 }
52336 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52338 if (!SWIG_IsOK(res2)) {
52339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52340 }
52341 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52342 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52343 if (!SWIG_IsOK(res3)) {
52344 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52345 }
52346 arg3 = reinterpret_cast< wxWindow * >(argp3);
52347 {
52348 PyThreadState* __tstate = wxPyBeginAllowThreads();
52349 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52350 wxPyEndAllowThreads(__tstate);
52351 if (PyErr_Occurred()) SWIG_fail;
52352 }
52353 {
52354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52355 }
52356 return resultobj;
52357 fail:
52358 return NULL;
52359 }
52360
52361
52362 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52363 PyObject *resultobj = 0;
52364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52365 wxEdge arg2 ;
52366 wxWindow *arg3 = (wxWindow *) 0 ;
52367 wxWindow *arg4 = (wxWindow *) 0 ;
52368 int result;
52369 void *argp1 = 0 ;
52370 int res1 = 0 ;
52371 int val2 ;
52372 int ecode2 = 0 ;
52373 void *argp3 = 0 ;
52374 int res3 = 0 ;
52375 void *argp4 = 0 ;
52376 int res4 = 0 ;
52377 PyObject * obj0 = 0 ;
52378 PyObject * obj1 = 0 ;
52379 PyObject * obj2 = 0 ;
52380 PyObject * obj3 = 0 ;
52381 char * kwnames[] = {
52382 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52383 };
52384
52385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52387 if (!SWIG_IsOK(res1)) {
52388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52389 }
52390 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52391 ecode2 = SWIG_AsVal_int(obj1, &val2);
52392 if (!SWIG_IsOK(ecode2)) {
52393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52394 }
52395 arg2 = static_cast< wxEdge >(val2);
52396 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52397 if (!SWIG_IsOK(res3)) {
52398 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52399 }
52400 arg3 = reinterpret_cast< wxWindow * >(argp3);
52401 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52402 if (!SWIG_IsOK(res4)) {
52403 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52404 }
52405 arg4 = reinterpret_cast< wxWindow * >(argp4);
52406 {
52407 PyThreadState* __tstate = wxPyBeginAllowThreads();
52408 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52409 wxPyEndAllowThreads(__tstate);
52410 if (PyErr_Occurred()) SWIG_fail;
52411 }
52412 resultobj = SWIG_From_int(static_cast< int >(result));
52413 return resultobj;
52414 fail:
52415 return NULL;
52416 }
52417
52418
52419 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52420 PyObject *obj;
52421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52422 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52423 return SWIG_Py_Void();
52424 }
52425
52426 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52429 wxIndividualLayoutConstraint *result = 0 ;
52430 void *argp1 = 0 ;
52431 int res1 = 0 ;
52432 PyObject *swig_obj[1] ;
52433
52434 if (!args) SWIG_fail;
52435 swig_obj[0] = args;
52436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52437 if (!SWIG_IsOK(res1)) {
52438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52439 }
52440 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52441 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52443 return resultobj;
52444 fail:
52445 return NULL;
52446 }
52447
52448
52449 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52450 PyObject *resultobj = 0;
52451 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52452 wxIndividualLayoutConstraint *result = 0 ;
52453 void *argp1 = 0 ;
52454 int res1 = 0 ;
52455 PyObject *swig_obj[1] ;
52456
52457 if (!args) SWIG_fail;
52458 swig_obj[0] = args;
52459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52460 if (!SWIG_IsOK(res1)) {
52461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52462 }
52463 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52464 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 PyObject *resultobj = 0;
52474 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52475 wxIndividualLayoutConstraint *result = 0 ;
52476 void *argp1 = 0 ;
52477 int res1 = 0 ;
52478 PyObject *swig_obj[1] ;
52479
52480 if (!args) SWIG_fail;
52481 swig_obj[0] = args;
52482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52483 if (!SWIG_IsOK(res1)) {
52484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52485 }
52486 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52487 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52489 return resultobj;
52490 fail:
52491 return NULL;
52492 }
52493
52494
52495 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52496 PyObject *resultobj = 0;
52497 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52498 wxIndividualLayoutConstraint *result = 0 ;
52499 void *argp1 = 0 ;
52500 int res1 = 0 ;
52501 PyObject *swig_obj[1] ;
52502
52503 if (!args) SWIG_fail;
52504 swig_obj[0] = args;
52505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52506 if (!SWIG_IsOK(res1)) {
52507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52508 }
52509 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52510 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52512 return resultobj;
52513 fail:
52514 return NULL;
52515 }
52516
52517
52518 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52519 PyObject *resultobj = 0;
52520 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52521 wxIndividualLayoutConstraint *result = 0 ;
52522 void *argp1 = 0 ;
52523 int res1 = 0 ;
52524 PyObject *swig_obj[1] ;
52525
52526 if (!args) SWIG_fail;
52527 swig_obj[0] = args;
52528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52529 if (!SWIG_IsOK(res1)) {
52530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52531 }
52532 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52533 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52535 return resultobj;
52536 fail:
52537 return NULL;
52538 }
52539
52540
52541 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52542 PyObject *resultobj = 0;
52543 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52544 wxIndividualLayoutConstraint *result = 0 ;
52545 void *argp1 = 0 ;
52546 int res1 = 0 ;
52547 PyObject *swig_obj[1] ;
52548
52549 if (!args) SWIG_fail;
52550 swig_obj[0] = args;
52551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52552 if (!SWIG_IsOK(res1)) {
52553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52554 }
52555 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52556 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52558 return resultobj;
52559 fail:
52560 return NULL;
52561 }
52562
52563
52564 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52565 PyObject *resultobj = 0;
52566 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52567 wxIndividualLayoutConstraint *result = 0 ;
52568 void *argp1 = 0 ;
52569 int res1 = 0 ;
52570 PyObject *swig_obj[1] ;
52571
52572 if (!args) SWIG_fail;
52573 swig_obj[0] = args;
52574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52575 if (!SWIG_IsOK(res1)) {
52576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52577 }
52578 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52579 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52581 return resultobj;
52582 fail:
52583 return NULL;
52584 }
52585
52586
52587 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52588 PyObject *resultobj = 0;
52589 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52590 wxIndividualLayoutConstraint *result = 0 ;
52591 void *argp1 = 0 ;
52592 int res1 = 0 ;
52593 PyObject *swig_obj[1] ;
52594
52595 if (!args) SWIG_fail;
52596 swig_obj[0] = args;
52597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52598 if (!SWIG_IsOK(res1)) {
52599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52600 }
52601 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52602 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52604 return resultobj;
52605 fail:
52606 return NULL;
52607 }
52608
52609
52610 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52611 PyObject *resultobj = 0;
52612 wxLayoutConstraints *result = 0 ;
52613
52614 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52615 {
52616 PyThreadState* __tstate = wxPyBeginAllowThreads();
52617 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52618 wxPyEndAllowThreads(__tstate);
52619 if (PyErr_Occurred()) SWIG_fail;
52620 }
52621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52622 return resultobj;
52623 fail:
52624 return NULL;
52625 }
52626
52627
52628 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52629 PyObject *resultobj = 0;
52630 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52631 void *argp1 = 0 ;
52632 int res1 = 0 ;
52633 PyObject *swig_obj[1] ;
52634
52635 if (!args) SWIG_fail;
52636 swig_obj[0] = args;
52637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52638 if (!SWIG_IsOK(res1)) {
52639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52640 }
52641 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52642 {
52643 PyThreadState* __tstate = wxPyBeginAllowThreads();
52644 delete arg1;
52645
52646 wxPyEndAllowThreads(__tstate);
52647 if (PyErr_Occurred()) SWIG_fail;
52648 }
52649 resultobj = SWIG_Py_Void();
52650 return resultobj;
52651 fail:
52652 return NULL;
52653 }
52654
52655
52656 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52657 PyObject *resultobj = 0;
52658 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52659 wxWindow *arg2 = (wxWindow *) 0 ;
52660 int *arg3 = (int *) 0 ;
52661 bool result;
52662 void *argp1 = 0 ;
52663 int res1 = 0 ;
52664 void *argp2 = 0 ;
52665 int res2 = 0 ;
52666 int temp3 ;
52667 int res3 = SWIG_TMPOBJ ;
52668 PyObject * obj0 = 0 ;
52669 PyObject * obj1 = 0 ;
52670 char * kwnames[] = {
52671 (char *) "self",(char *) "win", NULL
52672 };
52673
52674 arg3 = &temp3;
52675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52677 if (!SWIG_IsOK(res1)) {
52678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52679 }
52680 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52682 if (!SWIG_IsOK(res2)) {
52683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52684 }
52685 arg2 = reinterpret_cast< wxWindow * >(argp2);
52686 {
52687 PyThreadState* __tstate = wxPyBeginAllowThreads();
52688 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52689 wxPyEndAllowThreads(__tstate);
52690 if (PyErr_Occurred()) SWIG_fail;
52691 }
52692 {
52693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52694 }
52695 if (SWIG_IsTmpObj(res3)) {
52696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52697 } else {
52698 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52700 }
52701 return resultobj;
52702 fail:
52703 return NULL;
52704 }
52705
52706
52707 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52708 PyObject *resultobj = 0;
52709 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52710 bool result;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 PyObject *swig_obj[1] ;
52714
52715 if (!args) SWIG_fail;
52716 swig_obj[0] = args;
52717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52718 if (!SWIG_IsOK(res1)) {
52719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52720 }
52721 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52722 {
52723 PyThreadState* __tstate = wxPyBeginAllowThreads();
52724 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52725 wxPyEndAllowThreads(__tstate);
52726 if (PyErr_Occurred()) SWIG_fail;
52727 }
52728 {
52729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52730 }
52731 return resultobj;
52732 fail:
52733 return NULL;
52734 }
52735
52736
52737 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52738 PyObject *obj;
52739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52740 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52741 return SWIG_Py_Void();
52742 }
52743
52744 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52745 return SWIG_Python_InitShadowInstance(args);
52746 }
52747
52748 static PyMethodDef SwigMethods[] = {
52749 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52750 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52751 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52752 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52753 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52754 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52755 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52756 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52757 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52759 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52769 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52770 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52771 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52773 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52774 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52775 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52776 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52777 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52778 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52779 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52781 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52787 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52788 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52789 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52790 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52791 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52792 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52793 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52795 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52803 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52804 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52805 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52810 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52811 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52813 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52815 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52817 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52819 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52821 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52823 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52824 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52826 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52828 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52829 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52830 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52831 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52850 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52851 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52852 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52853 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52854 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52855 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52856 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52857 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52859 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52860 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52861 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52866 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52867 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52868 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52869 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52876 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52883 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52884 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52885 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52886 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52888 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52889 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52890 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52892 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52893 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52894 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52895 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52900 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52901 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52902 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52903 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52904 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52905 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52908 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52909 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52910 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52912 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52913 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52915 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52916 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52917 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52918 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52919 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52920 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52921 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52922 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52923 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52924 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52925 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52930 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52936 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52937 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52938 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52939 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52941 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52944 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52946 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52949 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52951 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52954 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52955 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52956 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52960 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52961 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52962 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52966 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52971 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52972 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52973 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52974 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52975 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52976 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52977 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52984 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52985 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52987 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52988 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52989 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52995 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52996 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52998 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52999 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53000 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53001 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53002 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53003 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53004 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53005 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53007 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53008 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53009 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53010 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53011 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53012 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53013 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53014 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53016 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53025 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53037 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53038 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53053 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53054 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53055 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53056 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53059 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53061 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53063 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53065 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53067 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53070 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53071 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53072 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53073 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53075 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53092 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53093 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53099 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53100 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53101 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53102 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53103 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53104 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53105 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53106 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53107 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53108 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53110 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53111 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53112 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53113 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53114 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53115 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53116 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53117 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53118 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53119 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53120 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53121 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53122 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53123 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53124 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53125 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53126 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53127 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53128 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53129 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53130 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53131 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53132 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53133 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53135 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53136 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53137 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53138 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53141 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53145 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53149 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53150 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53151 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53152 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53154 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53155 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53157 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53159 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53161 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53163 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53164 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53165 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53167 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53168 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53170 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53171 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53172 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53174 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53175 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53176 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53178 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53180 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53181 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53182 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53184 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53186 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53187 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53189 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53190 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53191 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53193 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53194 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53195 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53196 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53197 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53199 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53200 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53203 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53206 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53207 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53210 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53211 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53213 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53219 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53220 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53221 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53222 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53223 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53224 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53225 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53226 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53227 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53228 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53229 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53230 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53231 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53232 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53233 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53234 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53235 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53236 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53237 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53238 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53239 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53240 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53241 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53242 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53244 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53245 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53246 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53247 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53248 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53249 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53250 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53251 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53252 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53253 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53254 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53255 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53256 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53257 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53258 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53259 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53260 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53261 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53262 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53263 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53264 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53265 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53266 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53267 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53268 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53269 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53270 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53271 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53272 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53273 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53274 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53275 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53277 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53278 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53280 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53281 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53282 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53283 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53285 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53286 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53287 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53288 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53289 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53290 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53291 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53292 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53293 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53295 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53296 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53297 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53298 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53299 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53300 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53301 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53302 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53303 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53304 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53305 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53306 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53307 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53308 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53309 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53310 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53311 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53312 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53313 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53314 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53315 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53316 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53317 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53318 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53319 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53320 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53321 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53322 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53324 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53325 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53328 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53329 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53330 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53331 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53332 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53335 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53336 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53339 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53340 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53342 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53343 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53345 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53346 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53348 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53349 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53350 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53352 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53354 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53355 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53357 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53358 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53359 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53361 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53362 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53365 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53366 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53368 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53369 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53370 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53371 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53372 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53375 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53377 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53379 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53380 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53381 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53384 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53385 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53386 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53388 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53389 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53390 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53392 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53393 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53394 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53395 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53396 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53397 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53399 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53400 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53401 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53402 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53403 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53404 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53405 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53406 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53412 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53414 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53416 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53417 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53418 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53419 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53420 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53423 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53426 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53427 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53431 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53436 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53437 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53438 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53439 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53440 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53442 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53444 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53447 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53449 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53450 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53452 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53453 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53454 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53456 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53457 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53458 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53460 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53462 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53463 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53464 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53466 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53468 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53470 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53471 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53473 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53474 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53476 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53478 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53479 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53480 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53482 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53484 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53485 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53486 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53488 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53490 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53491 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53492 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53493 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53495 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53497 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53499 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53501 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53502 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53504 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53505 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53506 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53507 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53508 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53509 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53510 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53511 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53513 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53515 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53517 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53519 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53521 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53523 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53524 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53525 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53526 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53527 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53528 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53534 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53535 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53536 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53537 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53538 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53539 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53540 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53542 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53544 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53545 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53547 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53548 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53549 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53550 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53552 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53553 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53554 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53555 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53557 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53558 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53560 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53561 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53562 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53564 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53566 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53567 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53568 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53569 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53570 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53572 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53573 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53574 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53575 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53577 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53578 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53579 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53580 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53581 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53582 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53583 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53584 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53585 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53586 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53588 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53591 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53592 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53593 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53595 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53597 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53599 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53601 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53602 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53612 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53613 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53617 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53618 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53619 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53620 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53621 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53622 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53623 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53624 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53625 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53626 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53627 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53628 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53629 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53630 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53631 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53633 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53634 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53637 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53638 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53643 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53644 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53647 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53648 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53649 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53650 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53653 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53654 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53655 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53657 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53659 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53660 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53661 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53663 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53665 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53667 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53670 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53671 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53672 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53673 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53674 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53675 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53676 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53682 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53683 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53684 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53685 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53692 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53698 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53699 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53700 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53701 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53702 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53704 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53714 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53715 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53716 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53717 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53720 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53721 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53722 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53723 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53725 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53726 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53730 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53736 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53737 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53738 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53739 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53741 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53742 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53744 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53747 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53749 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53750 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53751 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53760 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53764 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53766 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53777 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53778 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53779 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53780 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53784 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53787 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53789 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53792 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53794 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53795 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53798 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53800 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53801 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53802 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53803 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53804 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53809 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53810 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53811 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53813 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53814 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53815 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53817 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53819 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53820 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53821 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53823 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53824 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53827 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53835 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53842 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53850 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53853 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53854 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53867 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53869 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53871 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53872 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53874 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53876 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53877 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53879 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53880 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53881 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53885 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53904 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53905 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53907 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53909 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53910 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53911 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53913 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53914 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53917 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53918 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53920 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53921 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53923 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53926 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53927 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53929 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53931 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53933 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53934 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53936 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53937 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53940 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53942 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53944 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53946 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53949 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53951 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53952 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53953 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53955 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53956 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53957 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53959 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53962 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53964 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53965 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53969 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53973 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53974 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53976 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53980 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53982 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53984 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53985 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53986 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53987 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53991 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53992 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53993 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53994 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53996 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53997 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54002 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54003 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54004 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54005 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54006 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54008 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54010 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54012 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54013 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54015 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54017 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54020 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54021 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54022 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54024 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54025 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54026 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54040 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54041 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54042 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54043 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54044 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54045 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54051 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54052 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54056 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54057 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54059 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54060 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54062 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54064 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54065 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54067 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54068 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54069 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54075 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54076 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54077 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54078 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54079 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54080 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54087 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54089 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54090 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54091 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54092 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54093 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54094 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54096 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54100 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54101 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54102 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54103 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54104 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54105 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54106 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54108 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54109 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54110 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54116 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54117 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54118 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54120 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54121 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54122 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54128 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54129 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54130 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54131 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54132 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54136 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54137 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54142 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54143 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54145 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54146 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54151 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54153 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54154 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54155 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54156 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54157 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54162 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54163 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54172 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54173 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54174 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54175 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54178 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54180 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54181 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54182 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54183 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54185 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54190 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54191 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54192 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54193 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54194 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54195 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54196 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54197 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54198 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54199 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54200 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54202 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54203 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54204 { NULL, NULL, 0, NULL }
54205 };
54206
54207
54208 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54209
54210 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54211 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54212 }
54213 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54214 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54215 }
54216 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54217 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54218 }
54219 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54220 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54221 }
54222 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54223 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54224 }
54225 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54226 return (void *)((wxSizer *) ((wxGridSizer *) x));
54227 }
54228 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54229 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54230 }
54231 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54232 return (void *)((wxSizer *) ((wxPySizer *) x));
54233 }
54234 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54235 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54236 }
54237 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54238 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54239 }
54240 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54242 }
54243 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54244 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54245 }
54246 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54247 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54248 }
54249 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54250 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54251 }
54252 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54253 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54254 }
54255 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54256 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54257 }
54258 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54259 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54260 }
54261 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54263 }
54264 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54266 }
54267 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54268 return (void *)((wxEvent *) ((wxPyEvent *) x));
54269 }
54270 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54271 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54272 }
54273 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54274 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54275 }
54276 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54277 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54278 }
54279 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54280 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54281 }
54282 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54283 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54284 }
54285 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54286 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54287 }
54288 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54289 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54290 }
54291 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54292 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54293 }
54294 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54295 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54296 }
54297 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54298 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54299 }
54300 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54301 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54302 }
54303 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54304 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54305 }
54306 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54307 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54308 }
54309 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54310 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54311 }
54312 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54313 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54314 }
54315 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54316 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54317 }
54318 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54319 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54320 }
54321 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54322 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54323 }
54324 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54325 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54326 }
54327 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54328 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54329 }
54330 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54331 return (void *)((wxEvent *) ((wxShowEvent *) x));
54332 }
54333 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54334 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54335 }
54336 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54337 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54338 }
54339 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54340 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54341 }
54342 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54343 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54344 }
54345 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54346 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54347 }
54348 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54349 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54350 }
54351 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54352 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54353 }
54354 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54355 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54356 }
54357 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54358 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54359 }
54360 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54361 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54362 }
54363 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54364 return (void *)((wxControl *) ((wxControlWithItems *) x));
54365 }
54366 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54367 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54368 }
54369 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54370 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54371 }
54372 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54373 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54374 }
54375 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54376 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54377 }
54378 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54379 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54380 }
54381 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54382 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54383 }
54384 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54385 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54386 }
54387 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54388 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54389 }
54390 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54391 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54392 }
54393 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54394 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54395 }
54396 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54397 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54398 }
54399 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54400 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54401 }
54402 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54403 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54404 }
54405 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54406 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54407 }
54408 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54409 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54410 }
54411 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54412 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54413 }
54414 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54415 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54416 }
54417 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54418 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54419 }
54420 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54421 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54422 }
54423 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54424 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54425 }
54426 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54427 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54428 }
54429 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54430 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54431 }
54432 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54433 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54434 }
54435 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54436 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54437 }
54438 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54439 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54440 }
54441 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54442 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54443 }
54444 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54445 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54446 }
54447 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54448 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54449 }
54450 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54451 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54452 }
54453 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54454 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54455 }
54456 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54457 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54458 }
54459 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54460 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54461 }
54462 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54463 return (void *)((wxObject *) ((wxSizerItem *) x));
54464 }
54465 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54467 }
54468 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54469 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54470 }
54471 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54472 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54473 }
54474 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54475 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54476 }
54477 static void *_p_wxSizerTo_p_wxObject(void *x) {
54478 return (void *)((wxObject *) ((wxSizer *) x));
54479 }
54480 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54481 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54482 }
54483 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54485 }
54486 static void *_p_wxEventTo_p_wxObject(void *x) {
54487 return (void *)((wxObject *) ((wxEvent *) x));
54488 }
54489 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54490 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54491 }
54492 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54493 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54494 }
54495 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54496 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54497 }
54498 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54500 }
54501 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54502 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54503 }
54504 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54505 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54506 }
54507 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54508 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54509 }
54510 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54511 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54512 }
54513 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54514 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54515 }
54516 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54517 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54518 }
54519 static void *_p_wxControlTo_p_wxObject(void *x) {
54520 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54521 }
54522 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54523 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54524 }
54525 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54526 return (void *)((wxObject *) ((wxFSFile *) x));
54527 }
54528 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54529 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54530 }
54531 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54532 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54533 }
54534 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54535 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54536 }
54537 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54538 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54539 }
54540 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54541 return (void *)((wxObject *) ((wxMenuItem *) x));
54542 }
54543 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54544 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54545 }
54546 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54547 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54548 }
54549 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54550 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54551 }
54552 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54553 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54554 }
54555 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54556 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54557 }
54558 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54559 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54560 }
54561 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54562 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54563 }
54564 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54565 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54566 }
54567 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54568 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54569 }
54570 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54571 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54572 }
54573 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54574 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54575 }
54576 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54577 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54578 }
54579 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54580 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54581 }
54582 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54583 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54584 }
54585 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54586 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54587 }
54588 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54589 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54590 }
54591 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54592 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54593 }
54594 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54595 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54596 }
54597 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54598 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54599 }
54600 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54601 return (void *)((wxObject *) ((wxImageHandler *) x));
54602 }
54603 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54604 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54605 }
54606 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54607 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54608 }
54609 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54610 return (void *)((wxObject *) ((wxEvtHandler *) x));
54611 }
54612 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54613 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54614 }
54615 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54616 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54617 }
54618 static void *_p_wxImageTo_p_wxObject(void *x) {
54619 return (void *)((wxObject *) ((wxImage *) x));
54620 }
54621 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54622 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54623 }
54624 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54625 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54626 }
54627 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54628 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54629 }
54630 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54631 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54632 }
54633 static void *_p_wxWindowTo_p_wxObject(void *x) {
54634 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54635 }
54636 static void *_p_wxMenuTo_p_wxObject(void *x) {
54637 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54638 }
54639 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54640 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54641 }
54642 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54643 return (void *)((wxObject *) ((wxFileSystem *) x));
54644 }
54645 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54646 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54647 }
54648 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54649 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54650 }
54651 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54652 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54653 }
54654 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54655 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54656 }
54657 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54658 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54659 }
54660 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54661 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54662 }
54663 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54664 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54665 }
54666 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54667 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54668 }
54669 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54670 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54671 }
54672 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54673 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54674 }
54675 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54676 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54677 }
54678 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54679 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54680 }
54681 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54682 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54683 }
54684 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54685 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54686 }
54687 static void *_p_wxControlTo_p_wxWindow(void *x) {
54688 return (void *)((wxWindow *) ((wxControl *) x));
54689 }
54690 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54691 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54692 }
54693 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54694 return (void *)((wxWindow *) ((wxMenuBar *) x));
54695 }
54696 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54697 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54698 }
54699 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54700 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54701 }
54702 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54703 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54704 }
54705 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54706 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54707 }
54708 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54709 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54710 }
54711 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54712 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54713 }
54714 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54715 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54716 }
54717 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54718 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54719 }
54720 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54721 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54722 }
54723 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54724 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54725 }
54726 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54727 return (void *)((wxValidator *) ((wxPyValidator *) x));
54728 }
54729 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54731 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};
54732 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54860
54861 static swig_type_info *swig_type_initial[] = {
54862 &_swigt__p_buffer,
54863 &_swigt__p_char,
54864 &_swigt__p_form_ops_t,
54865 &_swigt__p_int,
54866 &_swigt__p_long,
54867 &_swigt__p_unsigned_char,
54868 &_swigt__p_unsigned_int,
54869 &_swigt__p_unsigned_long,
54870 &_swigt__p_wxANIHandler,
54871 &_swigt__p_wxAcceleratorEntry,
54872 &_swigt__p_wxAcceleratorTable,
54873 &_swigt__p_wxActivateEvent,
54874 &_swigt__p_wxAppTraits,
54875 &_swigt__p_wxArrayString,
54876 &_swigt__p_wxBMPHandler,
54877 &_swigt__p_wxBitmap,
54878 &_swigt__p_wxBoxSizer,
54879 &_swigt__p_wxButton,
54880 &_swigt__p_wxCURHandler,
54881 &_swigt__p_wxCaret,
54882 &_swigt__p_wxChildFocusEvent,
54883 &_swigt__p_wxClipboardTextEvent,
54884 &_swigt__p_wxCloseEvent,
54885 &_swigt__p_wxColour,
54886 &_swigt__p_wxCommandEvent,
54887 &_swigt__p_wxContextMenuEvent,
54888 &_swigt__p_wxControl,
54889 &_swigt__p_wxControlWithItems,
54890 &_swigt__p_wxCursor,
54891 &_swigt__p_wxDC,
54892 &_swigt__p_wxDateEvent,
54893 &_swigt__p_wxDateTime,
54894 &_swigt__p_wxDisplayChangedEvent,
54895 &_swigt__p_wxDropFilesEvent,
54896 &_swigt__p_wxDuplexMode,
54897 &_swigt__p_wxEraseEvent,
54898 &_swigt__p_wxEvent,
54899 &_swigt__p_wxEventLoop,
54900 &_swigt__p_wxEventLoopActivator,
54901 &_swigt__p_wxEvtHandler,
54902 &_swigt__p_wxFSFile,
54903 &_swigt__p_wxFileSystem,
54904 &_swigt__p_wxFileSystemHandler,
54905 &_swigt__p_wxFlexGridSizer,
54906 &_swigt__p_wxFocusEvent,
54907 &_swigt__p_wxFont,
54908 &_swigt__p_wxFrame,
54909 &_swigt__p_wxGBPosition,
54910 &_swigt__p_wxGBSizerItem,
54911 &_swigt__p_wxGBSpan,
54912 &_swigt__p_wxGIFHandler,
54913 &_swigt__p_wxGridBagSizer,
54914 &_swigt__p_wxGridSizer,
54915 &_swigt__p_wxHelpEvent__Origin,
54916 &_swigt__p_wxICOHandler,
54917 &_swigt__p_wxIconizeEvent,
54918 &_swigt__p_wxIdleEvent,
54919 &_swigt__p_wxImage,
54920 &_swigt__p_wxImageHandler,
54921 &_swigt__p_wxImageHistogram,
54922 &_swigt__p_wxImage_HSVValue,
54923 &_swigt__p_wxImage_RGBValue,
54924 &_swigt__p_wxIndividualLayoutConstraint,
54925 &_swigt__p_wxInitDialogEvent,
54926 &_swigt__p_wxInputStream,
54927 &_swigt__p_wxInternetFSHandler,
54928 &_swigt__p_wxItemContainer,
54929 &_swigt__p_wxJPEGHandler,
54930 &_swigt__p_wxKeyEvent,
54931 &_swigt__p_wxLayoutConstraints,
54932 &_swigt__p_wxMaximizeEvent,
54933 &_swigt__p_wxMemoryFSHandler,
54934 &_swigt__p_wxMenu,
54935 &_swigt__p_wxMenuBar,
54936 &_swigt__p_wxMenuBarBase,
54937 &_swigt__p_wxMenuEvent,
54938 &_swigt__p_wxMenuItem,
54939 &_swigt__p_wxMouseCaptureChangedEvent,
54940 &_swigt__p_wxMouseEvent,
54941 &_swigt__p_wxMoveEvent,
54942 &_swigt__p_wxNavigationKeyEvent,
54943 &_swigt__p_wxNcPaintEvent,
54944 &_swigt__p_wxNotifyEvent,
54945 &_swigt__p_wxObject,
54946 &_swigt__p_wxOutputStream,
54947 &_swigt__p_wxPCXHandler,
54948 &_swigt__p_wxPNGHandler,
54949 &_swigt__p_wxPNMHandler,
54950 &_swigt__p_wxPaintEvent,
54951 &_swigt__p_wxPaletteChangedEvent,
54952 &_swigt__p_wxPaperSize,
54953 &_swigt__p_wxPoint,
54954 &_swigt__p_wxPoint2D,
54955 &_swigt__p_wxPropagateOnce,
54956 &_swigt__p_wxPropagationDisabler,
54957 &_swigt__p_wxPyApp,
54958 &_swigt__p_wxPyCommandEvent,
54959 &_swigt__p_wxPyDropTarget,
54960 &_swigt__p_wxPyEvent,
54961 &_swigt__p_wxPyFileSystemHandler,
54962 &_swigt__p_wxPyImageHandler,
54963 &_swigt__p_wxPyInputStream,
54964 &_swigt__p_wxPySizer,
54965 &_swigt__p_wxPyValidator,
54966 &_swigt__p_wxQuantize,
54967 &_swigt__p_wxQueryNewPaletteEvent,
54968 &_swigt__p_wxRealPoint,
54969 &_swigt__p_wxRect,
54970 &_swigt__p_wxRegion,
54971 &_swigt__p_wxScrollEvent,
54972 &_swigt__p_wxScrollWinEvent,
54973 &_swigt__p_wxSetCursorEvent,
54974 &_swigt__p_wxShowEvent,
54975 &_swigt__p_wxSize,
54976 &_swigt__p_wxSizeEvent,
54977 &_swigt__p_wxSizer,
54978 &_swigt__p_wxSizerItem,
54979 &_swigt__p_wxStaticBox,
54980 &_swigt__p_wxStaticBoxSizer,
54981 &_swigt__p_wxStdDialogButtonSizer,
54982 &_swigt__p_wxSysColourChangedEvent,
54983 &_swigt__p_wxTIFFHandler,
54984 &_swigt__p_wxToolTip,
54985 &_swigt__p_wxUpdateUIEvent,
54986 &_swigt__p_wxValidator,
54987 &_swigt__p_wxVisualAttributes,
54988 &_swigt__p_wxWindow,
54989 &_swigt__p_wxWindowCreateEvent,
54990 &_swigt__p_wxWindowDestroyEvent,
54991 &_swigt__p_wxXPMHandler,
54992 &_swigt__p_wxZipFSHandler,
54993 };
54994
54995 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54998 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54999 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55009 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}};
55010 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55011 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}};
55012 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55013 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}};
55014 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55021 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}};
55022 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55026 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55027 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55028 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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}};
55032 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55034 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}};
55035 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55037 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}};
55038 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}};
55039 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55047 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}};
55048 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55049 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}};
55050 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55053 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}};
55054 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55055 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55056 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55057 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55061 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}};
55062 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55078 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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_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_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_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
55079 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55085 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55110 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}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55119 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}};
55120 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55121 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}};
55122 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55126
55127 static swig_cast_info *swig_cast_initial[] = {
55128 _swigc__p_buffer,
55129 _swigc__p_char,
55130 _swigc__p_form_ops_t,
55131 _swigc__p_int,
55132 _swigc__p_long,
55133 _swigc__p_unsigned_char,
55134 _swigc__p_unsigned_int,
55135 _swigc__p_unsigned_long,
55136 _swigc__p_wxANIHandler,
55137 _swigc__p_wxAcceleratorEntry,
55138 _swigc__p_wxAcceleratorTable,
55139 _swigc__p_wxActivateEvent,
55140 _swigc__p_wxAppTraits,
55141 _swigc__p_wxArrayString,
55142 _swigc__p_wxBMPHandler,
55143 _swigc__p_wxBitmap,
55144 _swigc__p_wxBoxSizer,
55145 _swigc__p_wxButton,
55146 _swigc__p_wxCURHandler,
55147 _swigc__p_wxCaret,
55148 _swigc__p_wxChildFocusEvent,
55149 _swigc__p_wxClipboardTextEvent,
55150 _swigc__p_wxCloseEvent,
55151 _swigc__p_wxColour,
55152 _swigc__p_wxCommandEvent,
55153 _swigc__p_wxContextMenuEvent,
55154 _swigc__p_wxControl,
55155 _swigc__p_wxControlWithItems,
55156 _swigc__p_wxCursor,
55157 _swigc__p_wxDC,
55158 _swigc__p_wxDateEvent,
55159 _swigc__p_wxDateTime,
55160 _swigc__p_wxDisplayChangedEvent,
55161 _swigc__p_wxDropFilesEvent,
55162 _swigc__p_wxDuplexMode,
55163 _swigc__p_wxEraseEvent,
55164 _swigc__p_wxEvent,
55165 _swigc__p_wxEventLoop,
55166 _swigc__p_wxEventLoopActivator,
55167 _swigc__p_wxEvtHandler,
55168 _swigc__p_wxFSFile,
55169 _swigc__p_wxFileSystem,
55170 _swigc__p_wxFileSystemHandler,
55171 _swigc__p_wxFlexGridSizer,
55172 _swigc__p_wxFocusEvent,
55173 _swigc__p_wxFont,
55174 _swigc__p_wxFrame,
55175 _swigc__p_wxGBPosition,
55176 _swigc__p_wxGBSizerItem,
55177 _swigc__p_wxGBSpan,
55178 _swigc__p_wxGIFHandler,
55179 _swigc__p_wxGridBagSizer,
55180 _swigc__p_wxGridSizer,
55181 _swigc__p_wxHelpEvent__Origin,
55182 _swigc__p_wxICOHandler,
55183 _swigc__p_wxIconizeEvent,
55184 _swigc__p_wxIdleEvent,
55185 _swigc__p_wxImage,
55186 _swigc__p_wxImageHandler,
55187 _swigc__p_wxImageHistogram,
55188 _swigc__p_wxImage_HSVValue,
55189 _swigc__p_wxImage_RGBValue,
55190 _swigc__p_wxIndividualLayoutConstraint,
55191 _swigc__p_wxInitDialogEvent,
55192 _swigc__p_wxInputStream,
55193 _swigc__p_wxInternetFSHandler,
55194 _swigc__p_wxItemContainer,
55195 _swigc__p_wxJPEGHandler,
55196 _swigc__p_wxKeyEvent,
55197 _swigc__p_wxLayoutConstraints,
55198 _swigc__p_wxMaximizeEvent,
55199 _swigc__p_wxMemoryFSHandler,
55200 _swigc__p_wxMenu,
55201 _swigc__p_wxMenuBar,
55202 _swigc__p_wxMenuBarBase,
55203 _swigc__p_wxMenuEvent,
55204 _swigc__p_wxMenuItem,
55205 _swigc__p_wxMouseCaptureChangedEvent,
55206 _swigc__p_wxMouseEvent,
55207 _swigc__p_wxMoveEvent,
55208 _swigc__p_wxNavigationKeyEvent,
55209 _swigc__p_wxNcPaintEvent,
55210 _swigc__p_wxNotifyEvent,
55211 _swigc__p_wxObject,
55212 _swigc__p_wxOutputStream,
55213 _swigc__p_wxPCXHandler,
55214 _swigc__p_wxPNGHandler,
55215 _swigc__p_wxPNMHandler,
55216 _swigc__p_wxPaintEvent,
55217 _swigc__p_wxPaletteChangedEvent,
55218 _swigc__p_wxPaperSize,
55219 _swigc__p_wxPoint,
55220 _swigc__p_wxPoint2D,
55221 _swigc__p_wxPropagateOnce,
55222 _swigc__p_wxPropagationDisabler,
55223 _swigc__p_wxPyApp,
55224 _swigc__p_wxPyCommandEvent,
55225 _swigc__p_wxPyDropTarget,
55226 _swigc__p_wxPyEvent,
55227 _swigc__p_wxPyFileSystemHandler,
55228 _swigc__p_wxPyImageHandler,
55229 _swigc__p_wxPyInputStream,
55230 _swigc__p_wxPySizer,
55231 _swigc__p_wxPyValidator,
55232 _swigc__p_wxQuantize,
55233 _swigc__p_wxQueryNewPaletteEvent,
55234 _swigc__p_wxRealPoint,
55235 _swigc__p_wxRect,
55236 _swigc__p_wxRegion,
55237 _swigc__p_wxScrollEvent,
55238 _swigc__p_wxScrollWinEvent,
55239 _swigc__p_wxSetCursorEvent,
55240 _swigc__p_wxShowEvent,
55241 _swigc__p_wxSize,
55242 _swigc__p_wxSizeEvent,
55243 _swigc__p_wxSizer,
55244 _swigc__p_wxSizerItem,
55245 _swigc__p_wxStaticBox,
55246 _swigc__p_wxStaticBoxSizer,
55247 _swigc__p_wxStdDialogButtonSizer,
55248 _swigc__p_wxSysColourChangedEvent,
55249 _swigc__p_wxTIFFHandler,
55250 _swigc__p_wxToolTip,
55251 _swigc__p_wxUpdateUIEvent,
55252 _swigc__p_wxValidator,
55253 _swigc__p_wxVisualAttributes,
55254 _swigc__p_wxWindow,
55255 _swigc__p_wxWindowCreateEvent,
55256 _swigc__p_wxWindowDestroyEvent,
55257 _swigc__p_wxXPMHandler,
55258 _swigc__p_wxZipFSHandler,
55259 };
55260
55261
55262 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55263
55264 static swig_const_info swig_const_table[] = {
55265 {0, 0, 0, 0.0, 0, 0}};
55266
55267 #ifdef __cplusplus
55268 }
55269 #endif
55270 /* -----------------------------------------------------------------------------
55271 * Type initialization:
55272 * This problem is tough by the requirement that no dynamic
55273 * memory is used. Also, since swig_type_info structures store pointers to
55274 * swig_cast_info structures and swig_cast_info structures store pointers back
55275 * to swig_type_info structures, we need some lookup code at initialization.
55276 * The idea is that swig generates all the structures that are needed.
55277 * The runtime then collects these partially filled structures.
55278 * The SWIG_InitializeModule function takes these initial arrays out of
55279 * swig_module, and does all the lookup, filling in the swig_module.types
55280 * array with the correct data and linking the correct swig_cast_info
55281 * structures together.
55282 *
55283 * The generated swig_type_info structures are assigned staticly to an initial
55284 * array. We just loop though that array, and handle each type individually.
55285 * First we lookup if this type has been already loaded, and if so, use the
55286 * loaded structure instead of the generated one. Then we have to fill in the
55287 * cast linked list. The cast data is initially stored in something like a
55288 * two-dimensional array. Each row corresponds to a type (there are the same
55289 * number of rows as there are in the swig_type_initial array). Each entry in
55290 * a column is one of the swig_cast_info structures for that type.
55291 * The cast_initial array is actually an array of arrays, because each row has
55292 * a variable number of columns. So to actually build the cast linked list,
55293 * we find the array of casts associated with the type, and loop through it
55294 * adding the casts to the list. The one last trick we need to do is making
55295 * sure the type pointer in the swig_cast_info struct is correct.
55296 *
55297 * First off, we lookup the cast->type name to see if it is already loaded.
55298 * There are three cases to handle:
55299 * 1) If the cast->type has already been loaded AND the type we are adding
55300 * casting info to has not been loaded (it is in this module), THEN we
55301 * replace the cast->type pointer with the type pointer that has already
55302 * been loaded.
55303 * 2) If BOTH types (the one we are adding casting info to, and the
55304 * cast->type) are loaded, THEN the cast info has already been loaded by
55305 * the previous module so we just ignore it.
55306 * 3) Finally, if cast->type has not already been loaded, then we add that
55307 * swig_cast_info to the linked list (because the cast->type) pointer will
55308 * be correct.
55309 * ----------------------------------------------------------------------------- */
55310
55311 #ifdef __cplusplus
55312 extern "C" {
55313 #if 0
55314 } /* c-mode */
55315 #endif
55316 #endif
55317
55318 #if 0
55319 #define SWIGRUNTIME_DEBUG
55320 #endif
55321
55322 SWIGRUNTIME void
55323 SWIG_InitializeModule(void *clientdata) {
55324 size_t i;
55325 swig_module_info *module_head;
55326 static int init_run = 0;
55327
55328 clientdata = clientdata;
55329
55330 if (init_run) return;
55331 init_run = 1;
55332
55333 /* Initialize the swig_module */
55334 swig_module.type_initial = swig_type_initial;
55335 swig_module.cast_initial = swig_cast_initial;
55336
55337 /* Try and load any already created modules */
55338 module_head = SWIG_GetModule(clientdata);
55339 if (module_head) {
55340 swig_module.next = module_head->next;
55341 module_head->next = &swig_module;
55342 } else {
55343 /* This is the first module loaded */
55344 swig_module.next = &swig_module;
55345 SWIG_SetModule(clientdata, &swig_module);
55346 }
55347
55348 /* Now work on filling in swig_module.types */
55349 #ifdef SWIGRUNTIME_DEBUG
55350 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55351 #endif
55352 for (i = 0; i < swig_module.size; ++i) {
55353 swig_type_info *type = 0;
55354 swig_type_info *ret;
55355 swig_cast_info *cast;
55356
55357 #ifdef SWIGRUNTIME_DEBUG
55358 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55359 #endif
55360
55361 /* if there is another module already loaded */
55362 if (swig_module.next != &swig_module) {
55363 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55364 }
55365 if (type) {
55366 /* Overwrite clientdata field */
55367 #ifdef SWIGRUNTIME_DEBUG
55368 printf("SWIG_InitializeModule: found type %s\n", type->name);
55369 #endif
55370 if (swig_module.type_initial[i]->clientdata) {
55371 type->clientdata = swig_module.type_initial[i]->clientdata;
55372 #ifdef SWIGRUNTIME_DEBUG
55373 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55374 #endif
55375 }
55376 } else {
55377 type = swig_module.type_initial[i];
55378 }
55379
55380 /* Insert casting types */
55381 cast = swig_module.cast_initial[i];
55382 while (cast->type) {
55383 /* Don't need to add information already in the list */
55384 ret = 0;
55385 #ifdef SWIGRUNTIME_DEBUG
55386 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55387 #endif
55388 if (swig_module.next != &swig_module) {
55389 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55390 #ifdef SWIGRUNTIME_DEBUG
55391 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55392 #endif
55393 }
55394 if (ret) {
55395 if (type == swig_module.type_initial[i]) {
55396 #ifdef SWIGRUNTIME_DEBUG
55397 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55398 #endif
55399 cast->type = ret;
55400 ret = 0;
55401 } else {
55402 /* Check for casting already in the list */
55403 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55404 #ifdef SWIGRUNTIME_DEBUG
55405 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55406 #endif
55407 if (!ocast) ret = 0;
55408 }
55409 }
55410
55411 if (!ret) {
55412 #ifdef SWIGRUNTIME_DEBUG
55413 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55414 #endif
55415 if (type->cast) {
55416 type->cast->prev = cast;
55417 cast->next = type->cast;
55418 }
55419 type->cast = cast;
55420 }
55421 cast++;
55422 }
55423 /* Set entry in modules->types array equal to the type */
55424 swig_module.types[i] = type;
55425 }
55426 swig_module.types[i] = 0;
55427
55428 #ifdef SWIGRUNTIME_DEBUG
55429 printf("**** SWIG_InitializeModule: Cast List ******\n");
55430 for (i = 0; i < swig_module.size; ++i) {
55431 int j = 0;
55432 swig_cast_info *cast = swig_module.cast_initial[i];
55433 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55434 while (cast->type) {
55435 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55436 cast++;
55437 ++j;
55438 }
55439 printf("---- Total casts: %d\n",j);
55440 }
55441 printf("**** SWIG_InitializeModule: Cast List ******\n");
55442 #endif
55443 }
55444
55445 /* This function will propagate the clientdata field of type to
55446 * any new swig_type_info structures that have been added into the list
55447 * of equivalent types. It is like calling
55448 * SWIG_TypeClientData(type, clientdata) a second time.
55449 */
55450 SWIGRUNTIME void
55451 SWIG_PropagateClientData(void) {
55452 size_t i;
55453 swig_cast_info *equiv;
55454 static int init_run = 0;
55455
55456 if (init_run) return;
55457 init_run = 1;
55458
55459 for (i = 0; i < swig_module.size; i++) {
55460 if (swig_module.types[i]->clientdata) {
55461 equiv = swig_module.types[i]->cast;
55462 while (equiv) {
55463 if (!equiv->converter) {
55464 if (equiv->type && !equiv->type->clientdata)
55465 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55466 }
55467 equiv = equiv->next;
55468 }
55469 }
55470 }
55471 }
55472
55473 #ifdef __cplusplus
55474 #if 0
55475 {
55476 /* c-mode */
55477 #endif
55478 }
55479 #endif
55480
55481
55482
55483 #ifdef __cplusplus
55484 extern "C" {
55485 #endif
55486
55487 /* Python-specific SWIG API */
55488 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55489 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55490 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55491
55492 /* -----------------------------------------------------------------------------
55493 * global variable support code.
55494 * ----------------------------------------------------------------------------- */
55495
55496 typedef struct swig_globalvar {
55497 char *name; /* Name of global variable */
55498 PyObject *(*get_attr)(void); /* Return the current value */
55499 int (*set_attr)(PyObject *); /* Set the value */
55500 struct swig_globalvar *next;
55501 } swig_globalvar;
55502
55503 typedef struct swig_varlinkobject {
55504 PyObject_HEAD
55505 swig_globalvar *vars;
55506 } swig_varlinkobject;
55507
55508 SWIGINTERN PyObject *
55509 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55510 return PyString_FromString("<Swig global variables>");
55511 }
55512
55513 SWIGINTERN PyObject *
55514 swig_varlink_str(swig_varlinkobject *v) {
55515 PyObject *str = PyString_FromString("(");
55516 swig_globalvar *var;
55517 for (var = v->vars; var; var=var->next) {
55518 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55519 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55520 }
55521 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55522 return str;
55523 }
55524
55525 SWIGINTERN int
55526 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55527 PyObject *str = swig_varlink_str(v);
55528 fprintf(fp,"Swig global variables ");
55529 fprintf(fp,"%s\n", PyString_AsString(str));
55530 Py_DECREF(str);
55531 return 0;
55532 }
55533
55534 SWIGINTERN void
55535 swig_varlink_dealloc(swig_varlinkobject *v) {
55536 swig_globalvar *var = v->vars;
55537 while (var) {
55538 swig_globalvar *n = var->next;
55539 free(var->name);
55540 free(var);
55541 var = n;
55542 }
55543 }
55544
55545 SWIGINTERN PyObject *
55546 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55547 PyObject *res = NULL;
55548 swig_globalvar *var = v->vars;
55549 while (var) {
55550 if (strcmp(var->name,n) == 0) {
55551 res = (*var->get_attr)();
55552 break;
55553 }
55554 var = var->next;
55555 }
55556 if (res == NULL && !PyErr_Occurred()) {
55557 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55558 }
55559 return res;
55560 }
55561
55562 SWIGINTERN int
55563 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55564 int res = 1;
55565 swig_globalvar *var = v->vars;
55566 while (var) {
55567 if (strcmp(var->name,n) == 0) {
55568 res = (*var->set_attr)(p);
55569 break;
55570 }
55571 var = var->next;
55572 }
55573 if (res == 1 && !PyErr_Occurred()) {
55574 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55575 }
55576 return res;
55577 }
55578
55579 SWIGINTERN PyTypeObject*
55580 swig_varlink_type(void) {
55581 static char varlink__doc__[] = "Swig var link object";
55582 static PyTypeObject varlink_type;
55583 static int type_init = 0;
55584 if (!type_init) {
55585 const PyTypeObject tmp
55586 = {
55587 PyObject_HEAD_INIT(NULL)
55588 0, /* Number of items in variable part (ob_size) */
55589 (char *)"swigvarlink", /* Type name (tp_name) */
55590 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55591 0, /* Itemsize (tp_itemsize) */
55592 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55593 (printfunc) swig_varlink_print, /* Print (tp_print) */
55594 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55595 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55596 0, /* tp_compare */
55597 (reprfunc) swig_varlink_repr, /* tp_repr */
55598 0, /* tp_as_number */
55599 0, /* tp_as_sequence */
55600 0, /* tp_as_mapping */
55601 0, /* tp_hash */
55602 0, /* tp_call */
55603 (reprfunc)swig_varlink_str, /* tp_str */
55604 0, /* tp_getattro */
55605 0, /* tp_setattro */
55606 0, /* tp_as_buffer */
55607 0, /* tp_flags */
55608 varlink__doc__, /* tp_doc */
55609 0, /* tp_traverse */
55610 0, /* tp_clear */
55611 0, /* tp_richcompare */
55612 0, /* tp_weaklistoffset */
55613 #if PY_VERSION_HEX >= 0x02020000
55614 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55615 #endif
55616 #if PY_VERSION_HEX >= 0x02030000
55617 0, /* tp_del */
55618 #endif
55619 #ifdef COUNT_ALLOCS
55620 0,0,0,0 /* tp_alloc -> tp_next */
55621 #endif
55622 };
55623 varlink_type = tmp;
55624 varlink_type.ob_type = &PyType_Type;
55625 type_init = 1;
55626 }
55627 return &varlink_type;
55628 }
55629
55630 /* Create a variable linking object for use later */
55631 SWIGINTERN PyObject *
55632 SWIG_Python_newvarlink(void) {
55633 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55634 if (result) {
55635 result->vars = 0;
55636 }
55637 return ((PyObject*) result);
55638 }
55639
55640 SWIGINTERN void
55641 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55642 swig_varlinkobject *v = (swig_varlinkobject *) p;
55643 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55644 if (gv) {
55645 size_t size = strlen(name)+1;
55646 gv->name = (char *)malloc(size);
55647 if (gv->name) {
55648 strncpy(gv->name,name,size);
55649 gv->get_attr = get_attr;
55650 gv->set_attr = set_attr;
55651 gv->next = v->vars;
55652 }
55653 }
55654 v->vars = gv;
55655 }
55656
55657 SWIGINTERN PyObject *
55658 SWIG_globals() {
55659 static PyObject *_SWIG_globals = 0;
55660 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55661 return _SWIG_globals;
55662 }
55663
55664 /* -----------------------------------------------------------------------------
55665 * constants/methods manipulation
55666 * ----------------------------------------------------------------------------- */
55667
55668 /* Install Constants */
55669 SWIGINTERN void
55670 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55671 PyObject *obj = 0;
55672 size_t i;
55673 for (i = 0; constants[i].type; ++i) {
55674 switch(constants[i].type) {
55675 case SWIG_PY_POINTER:
55676 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55677 break;
55678 case SWIG_PY_BINARY:
55679 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55680 break;
55681 default:
55682 obj = 0;
55683 break;
55684 }
55685 if (obj) {
55686 PyDict_SetItemString(d, constants[i].name, obj);
55687 Py_DECREF(obj);
55688 }
55689 }
55690 }
55691
55692 /* -----------------------------------------------------------------------------*/
55693 /* Fix SwigMethods to carry the callback ptrs when needed */
55694 /* -----------------------------------------------------------------------------*/
55695
55696 SWIGINTERN void
55697 SWIG_Python_FixMethods(PyMethodDef *methods,
55698 swig_const_info *const_table,
55699 swig_type_info **types,
55700 swig_type_info **types_initial) {
55701 size_t i;
55702 for (i = 0; methods[i].ml_name; ++i) {
55703 const char *c = methods[i].ml_doc;
55704 if (c && (c = strstr(c, "swig_ptr: "))) {
55705 int j;
55706 swig_const_info *ci = 0;
55707 const char *name = c + 10;
55708 for (j = 0; const_table[j].type; ++j) {
55709 if (strncmp(const_table[j].name, name,
55710 strlen(const_table[j].name)) == 0) {
55711 ci = &(const_table[j]);
55712 break;
55713 }
55714 }
55715 if (ci) {
55716 size_t shift = (ci->ptype) - types;
55717 swig_type_info *ty = types_initial[shift];
55718 size_t ldoc = (c - methods[i].ml_doc);
55719 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55720 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55721 if (ndoc) {
55722 char *buff = ndoc;
55723 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55724 if (ptr) {
55725 strncpy(buff, methods[i].ml_doc, ldoc);
55726 buff += ldoc;
55727 strncpy(buff, "swig_ptr: ", 10);
55728 buff += 10;
55729 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55730 methods[i].ml_doc = ndoc;
55731 }
55732 }
55733 }
55734 }
55735 }
55736 }
55737
55738 #ifdef __cplusplus
55739 }
55740 #endif
55741
55742 /* -----------------------------------------------------------------------------*
55743 * Partial Init method
55744 * -----------------------------------------------------------------------------*/
55745
55746 #ifdef __cplusplus
55747 extern "C"
55748 #endif
55749 SWIGEXPORT void SWIG_init(void) {
55750 PyObject *m, *d;
55751
55752 /* Fix SwigMethods to carry the callback ptrs when needed */
55753 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55754
55755 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55756 d = PyModule_GetDict(m);
55757
55758 SWIG_InitializeModule(0);
55759 SWIG_InstallConstants(d,swig_const_table);
55760
55761
55762
55763 #ifndef wxPyUSE_EXPORT
55764 // Make our API structure a CObject so other modules can import it
55765 // from this module.
55766 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55767 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55768 Py_XDECREF(cobj);
55769 #endif
55770
55771 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55772 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55773 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55774 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55775 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55776 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55777 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55778 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55779 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55780 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55781 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55782 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55783 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55784 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55785 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55786 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55787 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55788 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55789 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55790 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55791 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55792 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55793 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55794 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55795 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55796 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55797 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55798 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55799 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55800 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55801 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55802 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55803 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55804 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55805 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55806 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55807 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55808 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55809 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55810 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55811 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55812 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55813 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55814 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55815 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55816 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55817 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55818 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55819 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55820 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55821 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55822 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55823 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55824 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55825 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55826 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55827 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55828 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55829 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55830 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55831 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55832 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55833 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55834 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55835 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55836 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55837 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55838 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55839 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55840 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55841 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55842 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55843 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55844 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55845 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55846 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55847 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55848 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55849 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55850 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55851 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55852 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55853 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55854 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55855 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55856 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55857 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55858 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55859 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55860 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55861 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55862 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55863 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55864 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55865 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55866 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55867 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55868 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55869 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55870 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55871 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55872 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55873 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55874 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55875 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55876 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55877 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55878 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55879 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55880 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55881 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55882 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55883 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55884 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55885 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55886 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55887 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55888 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55889 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55890 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55891 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55892 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55893 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55894 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55895 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55896 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55897 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55898 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55899 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55900 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55901 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55902 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55903 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55904 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55905 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55906 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55907 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55908 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55909 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55910 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55911 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55912 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55913 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55914 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55915 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55916 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55917 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55918 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55919 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55920 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55921 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55922 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55923 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55924 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55925 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55926 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55927 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55928 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55929 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55930 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55931 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55932 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55933 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55934 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55935 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55936 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55937 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55938 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55939 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55940 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55941 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55942 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55943 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55944 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55945 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55946 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55947 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55948 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55949 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55950 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55951 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55952 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55953 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55954 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55955 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55956 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55957 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55958 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55959 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55960 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55961 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55962 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55963 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55964 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55965 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55966 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55967 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55968 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55969 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55970 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55971 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55972 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55973 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55974 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55975 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55976 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55977 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55978 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55979 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55980 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55981 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55982 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55983 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55984 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55985 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55986 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55987 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55988 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55989 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55990 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55991 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55992 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55993 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55994 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55995 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55996 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55997 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55998 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55999 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56000 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56001 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56002 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56003 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56004 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56005 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56006 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56007 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56008 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56009 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56010 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56011 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56012 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56013 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56014 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56015 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56016 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56017 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56018 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56019 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56020 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56021 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56022 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56023 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56024 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56025 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56026 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56027 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56028 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56029 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56030 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56031 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56032 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56033 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56034 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56035 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56036 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56037 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56038 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56039 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56040 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56041 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56042 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56043 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56044 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56045 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56046 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56047 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56048 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56049 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56050 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56051 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56052 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56053 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56054 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56055 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56056 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56057 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56058 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56059 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56060 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56061 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56062 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56063 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56064 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56065 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56066 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56067 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56068 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56069 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56070 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56071 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56072 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56073 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56074 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56075 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56076 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56077 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56078 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56079 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56080 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56081 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56082 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56083 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56084 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56085 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56086 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56087 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56088 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56089 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56090 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56091 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56092 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56093 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56094 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56095 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56096 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56097 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56098 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56099 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56100 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56101 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56102 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56103 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56104 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56105 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56106 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56107 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56108 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56109 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56110 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56111 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56112 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56113 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56114 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56115 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56116 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56117 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56118 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56119 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56120 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56121 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56122 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56123 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56124 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56125 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56126 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56127 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56128 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56129 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56130 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56131 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56132 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56133 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56134 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56135 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56136 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56137 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56138 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56139 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56140 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56141 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56142 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56143 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56144 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56145 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56146 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56147 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56148 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56149 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56150 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56151 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56152 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56153 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56154 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56155 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56156 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56157 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56158 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56159 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56160 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56161 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56162 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56163 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56164 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56165 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56166 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56167 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56169 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56170 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56171 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56173 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56174 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56175 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56185 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56186 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56187 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56188 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56199 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56200 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56201 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56202 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56203 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56204 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56205 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56206 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56207 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56208 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56209 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56210 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56211 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56212 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56213 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56214 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56215 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56216 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56217 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56218 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56219 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56220 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56221 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56222 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56223 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56224 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56225 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56226 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56227 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56228 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56229 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56230 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56231 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56232 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56233 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56234 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56235 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56236 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56237 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56238 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56239 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56240 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56241 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56242 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56243 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56244 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56245 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56246 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56247 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56248 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56249 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56250 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56251 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56252 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56253 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56254 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56255 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56256 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56257 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56258 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56259 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56260 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56261 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56262 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56263 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56264 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56265 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56266 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56267 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56268 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56269 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56270 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56271 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56272 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56273 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56274 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56275 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56276 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56277 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56278 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56279 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56280 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56281 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56282 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56283 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56284 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56285 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56286 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56287 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56288 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56289 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56290 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56291 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56292 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56293 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56294 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56295 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56296 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56297 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56298 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56299 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56300 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56301 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56302 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56303 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56304 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56310 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56312 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56313 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56314 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56315 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56316 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56317 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56318 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56319 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56320 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56321 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56322 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56323 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56324 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56325 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56326 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56327 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56328 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56329 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56330 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56331 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56332 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56333 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56334 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56335 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56336 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56337 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56338 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56339 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56340 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56341 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56342 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56343 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56344 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56345 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56346 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56347 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56348 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56349 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56350 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56351 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56352 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56353 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56354 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56355 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56356 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56357 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56358 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56359 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56360 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56361 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56362 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56363 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56364 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56365 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56366 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56367 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56368 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56369 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56370 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56371 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56372 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56373 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56374 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56375 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56376 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56377 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56378 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56379 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56380 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56381 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56382 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56383 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56384 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56385 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56388 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56389 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56390 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56391 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56392 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56393 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56394 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56398 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56399 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56400 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56401 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56402 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56403 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56404 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56405 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56406 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56407 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56408 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56409 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56410 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56411 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56412 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56413 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56414 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56415 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56416 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56417 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56418 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56419 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56420 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56421 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56422 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56423 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56424 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56425 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56426 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56427 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56428 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56429 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56430 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56431 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56432 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56433 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56434
56435 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56436
56437
56438 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56439
56440 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56441 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56442 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56443 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56444 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56445 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56446 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56447 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56448 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56449 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56450 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56451 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56453 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56454 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56457 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56458 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56459 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56460 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56461 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56462 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56463 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56464 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56465 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56466 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56467 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56468 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56469 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56470 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56471 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56472 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56473 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56474 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56475 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56476 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56477 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56478 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56479 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56480 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56481 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56482 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56483 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56484 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56485 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56486 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56487 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56488 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56489 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56490 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56491 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56492 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56493 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56494 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56495 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56496 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56497 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56498 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56499 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56500 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56501 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56502 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56503 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56504 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56505 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56506 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56507 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56508 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56509 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56510 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56511 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56512 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56513 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56514 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56515 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56516 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56517 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56518 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56519 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56520 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56521 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56522 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56523 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56524 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56525 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56526 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56527 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56528 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56529 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56530 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56531 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56532 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56533 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56534 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56535 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56536 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56537 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56538 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56539 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56540 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56541 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56542 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56543 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56544 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56545 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56546 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56547 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56548 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56549 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56550 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56551 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56552 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56553 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56554 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56555 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56556 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56557 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56558 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56559 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56560 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56561 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56562 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56563 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56564 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56565 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56566 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56567 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56568 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56569 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56570 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56571 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56572 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56573 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56574 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56575 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56576 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56577 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56578 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56579 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56580 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56581 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56582 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56583 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56584 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56585 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56586 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56587 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56591 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56592 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56593 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56594 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56595 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56596 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56597 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56598 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56599 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56600 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56601 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56602 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56603 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56604 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56605 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56606 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56607 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56608 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56609 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56610 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56611 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56612 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56613 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56614 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56615 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56616 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56617 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56618 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56619 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56620 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56621 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56622 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56623 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56624 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56625 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56626 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56627 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56628 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56629 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56630 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56631 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56632 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56633 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56634 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56635 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56636 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56637 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56638 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56639 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56640 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56641 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56642 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56643 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56644 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56645 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56646
56647 // Initialize threading, some globals and such
56648 __wxPyPreStart(d);
56649
56650
56651 // Although these are defined in __version__ they need to be here too so
56652 // that an assert can be done to ensure that the wxPython and the wxWindows
56653 // versions match.
56654 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56655 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56656 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56657
56658 }
56659
wxWidgets (Impactor)